{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github", "colab_type": "text" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false, "deletable": false, "editable": false, "id": "7MawMT1XNzgn" }, "source": [ "## First steps\n", "\n", "To start, either download this notebook and run it locally, or else click on 'Open in Colab' above. Then click on the triangle below. " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "editable": false, "jupyter": { "source_hidden": false }, "id": "jxhALRpsNzgr" }, "outputs": [], "source": [ "!python -m pip install -U setuptools\n", "!python -m pip install -U git+https://github.com/lmoss/onesharp.git@main\n", "from onesharp.interpreter.interpreter import *" ] }, { "cell_type": "markdown", "source": [ "Welcome to our first tutorial lesson on $\\one\\hash$. You will learn the basics of the language here and also see some small programs.\n", "\n", "This lesson is written on a lower level than the lessons which come after it. The only abstract concept comes at the end, as does the only and mathematical notation. The rest of the lesson is a concrete introduction to $\\one\\hash$.\n", "\n", "If you are familiar with any machine model in the theory of computations, such as Turing Machines, or classical register machines, you probably will want to skim through this lesson quickly.\n", "\n", "But this introductory lesson is really intended for people with no background on these matters. If this is you, please work slowly, doing the exercises as you go.\n" ], "metadata": { "id": "Fgp0e5TPkQc_" } }, { "cell_type": "markdown", "source": [ "To begin, here is an *interpreter* for $\\mathtt{1\\#}$. Even before learning how the language works, we want to see how to run programs by entering them into the interpreter along with inputs." ], "metadata": { "id": "gU8rrAp25Zar" } }, { "cell_type": "code", "source": [ "def end_strip(list): ## removes the tail of empty registers\n", " if list == []:\n", " return(list)\n", " elif list[-1] == '':\n", " return(end_strip(list[:-1]))\n", " else:\n", " return(list)\n", "def remove_multiple_blanks(my_str):\n", " return(my_str.replace(\" \", \"\"))\n", "\n", "\n", "program = '11#####111111###111###1##1111####1#111111####' #@param {type:\"string\"}\n", "R1 = '#11###1' #@param {type:\"string\"}\n", "R2 = '11111#' #@param {type:\"string\"}\n", "#R3 = '' #@param {type:\"string\"}\n", "\n", "## For more registers, add lines here like\n", "## R4 = '' #@param {type:\"string\"}\n", "## You also must modify the definition of 'a' below accordingly.\n", "\n", "# First, we delete the last batch of empty registers\n", "# to simplify the output \n", "a = [R1,R2]\n", "a = [remove_multiple_blanks(x) for x in a]\n", "\n", "onesharp(program,a)\n" ], "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 35 }, "id": "MPjUbJF95HHZ", "outputId": "e8895691-c471-450f-d471-15fd807e8057", "cellView": "form" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'#11###111111#'" ], "application/vnd.google.colaboratory.intrinsic+json": { "type": "string" } }, "metadata": {}, "execution_count": 5 } ] }, { "cell_type": "markdown", "source": [ "The top line of the interpreter contains the following *program* of $\\one\\hash$:\n", "\n", "```11#####111111###111###1##1111####1#111111####```\n", "\n", "The other two lines are the *inputs* to two *registers*. Those inputs are the same kind of mathematical object as the program: they are *words* on the alphabet $\\set{\\one,\\hash}$. In this book, words are just sequences composed of the symbols ```1``` and ```#```, such as ```11###11#1``` and ```#1###1###111#11```. We'll have more to say about and programs soon. But for now, modify the inputs to R1 and R2, but keep the program the same. Click on the arrow to run the program on the inputs, and look at the *output* below the interpreter.\n", "\n", "Another way to run the program is to type shift-return on a keyboard. The output is shown below the interpreter, above the current cell.\n", "\n", "\n", "The empty word is a perfectly good word, so you could also enter it into R1 or R2 just by leaving the register blank or by entering one or more spaces.\n", "\n", "You can modify $\\Rone$ and $\\Rtwo$ as many times as you like.\n", "\n", "What you should find after doing this is that the output is the input in $\\Rone$ followed by the input in $\\Rtwo$. We usually will say *concatenated* instead of *followed by*.\n", "\n", "---\n", "\n", "The overall point is that the program ```11#####111111###111###1##1111####1#111111####``` may be run on words which are input in the registers. This program does not change when we run it. Our little interpreter didn't show the step-by-step behavior of the register machine, it only showed the final output. We'll return to the soon, after we understand what the program is doing. It turns out that this program is composed of seven instructions. We'll get to the instructions soon, but first we have an exercise for you to try." ], "metadata": { "id": "3BOQeYtdk84Q" } }, { "cell_type": "markdown", "source": [ "```{exercise}\n", "Here is another 1# program. It takes its input from the first two registers. Enter some words in R1 and R2 input boxes, and then run the program. Your job is to try to figure out what the program does.\n", "\n", "```1##### 11111111### 1111### 111## 1111## 11111#### 111# 1111# 11111111#### 111##### 111111### 111### 1## 1111#### 1# 111111#### 1111##### 111111### 111### 1## 1111#### 1# 111111#### 11##### 111111### 111### 1## 1111#### 1# 111111####```\n", "```" ], "metadata": { "id": "AehFgcJH8Nh3" } }, { "cell_type": "markdown", "source": [ "## The $\\mathtt{1\\#}$ instruction set\n", "\n", "We are going to present the full set of instructions of $\\one\\hash$. There are five instruction types. \n", "\n", "```{attention} \n", "When we use superscripts and write, for example, $\\one^k \\hash^{\\ell}$ we mean $k$ copies of the symbol $\\one$ followed by $\\ell$ copies of the symbol $\\hash$. For example,\n", "\n", "$\n", "\\one^{15}\\hash^4$ abbreviates $\\one\\one \\one \\one \\one \\one \\one \\one \\one \\one \\one \\one \\one \\one \\one \\hash\\hash\\hash\\hash \n", "$.\n", "\n", "We also write this as 1^15 #^4.\n", "```" ], "metadata": { "id": "7LZxPKVEcNfX" } }, { "cell_type": "markdown", "source": [ "So far, we have seen two *programs* of $\\mathtt{1\\#}$. Programs are composed of *instructions*. In fact, programs are just sequences of instructions run together. There are only five kinds of $\\mathtt{1\\#}$ instructions. Now is the time to introduce them.\n", "\n", "We begin our journey with the first two types of instructions of the language.\n", "\n", "| Instruction | Meaning |\n", "| ----------- | ----------- |\n", "| 1# | Add 1 to R1 |\n", "| 11# | Add 1 to R2 |\n", "| 111# | Add 1 to R3 |\n", "\n", "\n", "These instructions add a $\\mathtt{1}$ to the end of the word (the right end, as in English words) in the specified register.\n", "\n", "\n", "| Instruction | Meaning |\n", "| ----------- | ----------- |\n", "| 1## | Add # to R1 |\n", "| 11## | Add # to R2 |\n", "| 111## | Add # to R3 |\n", "\t\t\n", "\n", "These add a $\\mathtt{\\#}$ to the end (again, this means the right side) of the word in the specified register. We can summarize the two kinds of instructions which we have seen, and also extend them:\n", "\n", "| Instruction | Meaning |\n", "| ----------- | ----------- |\n", "| 1^n # | Add 1 to Rn |\n", "| 1^n ## | Add # to Rn |\n", "\n", "The programs of $\\mathtt{1\\#}$ are just sequences of instructions run together. There is no punctuation between the instructions. To move around in a program, we have two other kinds of instructions\n", "\n", "| Instruction | Meaning |\n", "| ----------- | ----------- |\n", "| 1^n ### | Go forward n instructions |\n", "| 1^n #### | Go backward n instructions |\n", "\n", "Here is the last kind of instruction:\n", "\n", "| Instruction | Meaning |\n", "| ----------- | ----------- |\n", "| 1^n ##### | Cases on register n |\n", "\n", "Here is what it does:\n", "\n", "If Rn is empty, we go to the very next instruction.\n", "\n", "If the first symbol of Rn is $\\mbox{\\mathtt{1}}$, we delete that symbol and go to the second instruction after the case instruction.\n", "\n", "If the first symbol of Rn is $\\hash$, we delete that symbol and go to the third instruction after the case instruction.\n", "\n", "The 'cases' instructions are the most complex to understand, and it will help to look an example in detail. But first we have some exercises on the 1^n# and 1^n## instructions." ], "metadata": { "id": "aq0g8aLp8aCW" } }, { "cell_type": "markdown", "source": [ "```{exercise}\n", ":label: try-to-figure\n", "Again, start with $\\mathtt{1}$ in R1 and R2, $\\mathtt{1\\#}$ in R3, and the other registers empty.\n", "What happens in each register if we run\n", "$\\mathtt{111\\#\\#}$?\n", "Try to figure this out for yourself, and then check your work by actually running the program.\n", "```" ], "metadata": { "id": "mPeznuRfMGTV" } }, { "cell_type": "markdown", "source": [ "```{exercise}\n", "As before, start with $\\one$ in R1 and R2, $\\mathtt{1\\#}$ in R3, and the other registers empty.\n", "What happens in each register if we run the same program \n", "$\\mathtt{111\\#\\#}$ from the previous exercise?\n", "```" ], "metadata": { "id": "pciRDq5HMLZK" } }, { "cell_type": "markdown", "source": [ "```{exercise}\n", "Write a program which, when started with all registers empty, gives $\\mathtt{1}$ in R1 and R2, $\\mathtt{1\\#}$ in R3, and the other registers empty.\n", "```" ], "metadata": { "id": "02Hu2bGhMTnm" } }, { "cell_type": "markdown", "source": [ "" ], "metadata": { "id": "uHT06l0nzXOf" } }, { "cell_type": "markdown", "source": [ "# What are programs?\n", "\n", "```{important}\n", "A *program* is a sequence of instructions run together.\n", "```\n", "\n", "We have already been using this terminology. For example, we saw\n", "\n", "11#####111111###111###1##1111####1#111111####\n", "\n", "near the top of this notebook. This is the following sequence of instructions:\n", "\n", "11##### 111111### 111### 1## 1111#### 1# 111111####\n", "\n", "Dividing a program into instructions is a very easy form of *parsing*. In a real computer language, parsing is more difficult than it is for $\\one\\hash$. \n", "\n", "Incidentally, spaces are not significant in the interpreter above, or in the work we'll turn to shortly. You may enter programs with spaces.\n", "\n", "Let us emphasize something about programs.\n", "\n", "```{important}\n", "Any sequence of $\\one\\hash$ instructions is a program. A program doesn't come with an explanation of what \"it is supposed to do\".\n", "```\n" ], "metadata": { "id": "kFwH6_CugCNx" } }, { "cell_type": "markdown", "source": [ "```{important}\n", "Words have to be *finite*, and so programs also must be finite. Further, each program $p$ of $\\one\\hash$ can only mention finitely many registers. \n", "\n", "(That is, there is a finite set $F\\subseteq \\N$ such that if\n", " $\\one^k \\hash$ is an instruction in $p$, then $k\\in F$;\n", "if $\\one^k \\hash\\hash$ is an instruction in $p$, then $k\\in F$;\n", "and $\\one^k \\hash^5$ is an instruction in $p$, then $k\\in F$.)\n", "```" ], "metadata": { "id": "HQ3wlzp5eDEm" } }, { "cell_type": "markdown", "source": [ "# Running programs in notebook cells\n", "\n", "Because notebooks like this are composed of cells, we also want to run programs in a command-line fashion.\n", "\n", "There are two programs that do this. They are \n", "```step_by_step``` and ```onesharp```. These are illustrated in the next two cells. Both of these programs are written in Python, not in $\\mathtt{1\\#}$. They both require as inputs a $\\mathtt{1\\#}$ program followed by a sequence of register words." ], "metadata": { "id": "h0f-UGdqFeoO" } }, { "cell_type": "code", "source": [ "onesharp('1#11#####1###1###',['1#1','#'])" ], "metadata": { "id": "TGPYIuyWF7kg", "colab": { "base_uri": "https://localhost:8080/", "height": 35 }, "outputId": "4b234d77-6fa3-4f3e-f8ab-9ac9df4c1f35" }, "execution_count": null, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'1#11'" ], "application/vnd.google.colaboratory.intrinsic+json": { "type": "string" } }, "metadata": {}, "execution_count": 22 } ] }, { "cell_type": "code", "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": true }, "scrolled": true, "id": "VPQDvFNPNzgw", "collapsed": true, "colab": { "base_uri": "https://localhost:8080/", "height": 710 }, "outputId": "05b462e1-fd8d-4902-b965-6e491e06ac4f" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "First, here is the program:\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 instructionexplanation
11#add 1 to R1
211#####cases on R2
31###go forward 1 to instruction 4
41###go forward 1 to instruction 5
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "The computation starts with the register contents shown below.\n", "The registers include those those which you entered as part of the input\n", "and also others mentioned in the input program.\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 contents
11#1
2#
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "Step 1:\n", "Execute instruction 1: add 1 to R1.\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 contents
11#11
2#
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Step 2:\n", "Execute instruction 2: cases on R2.\n", "The first symbol in that register is #, so we delete that symbol and go forward 3 instructions.\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 contents
11#11
2
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "The computation then halts properly because the control is just below the last line of the program,\n", "and because all registers other than R1 are empty.\n", "The output is 1#11.\n" ] } ], "source": [ "step_by_step('1#11#####1###1###',['1#1','#'])" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": true }, "id": "UryssEaVNzgx" }, "source": [ "The last computation started with two inputs. Try changing those inputs to see what happens. As practice with the definition of *halt*, you might try yourself to predict what will happen before running it. You can add the symbols $\\mathtt{1}$ or $\\mathtt{\\#}$, and you also can delete symbols. But you should not delete the quote marks. Also, you can change the program the same way. The idea is that you should explore this function *step_by_step* by trying it out on simple inputs. " ] }, { "cell_type": "markdown", "metadata": { "collapsed": false, "id": "cxghpbUSNzgx" }, "source": [ "Here is an explanation of the form of the command ```step_by_step``` that we have been using. \n", "\n", "The first argument could be a $\\mathtt{1\\#}$ program surrounded by single quotes or double-quotes. If you use single quotes, you need to be sure to use the correct ones; on my screen they look straight, not slanted. You could also use a concatenation of quoted expressions (see below). But if you forget the quotes, you will get an error because the Python program that is running all of this will balk at $\\mathtt{1\\#}$ expressions without quotes around them.\n", "\n", "In addition, you can name expressions ahead of time using assignment statements like \n", "\n", "```p = '1#'```\n", "\n", "\n", "and then enter (for example)\n", "\n", " ```step_by_step(p,['11'])```.\n", "\n", "---\n", "\n", "The program ```step_by_step``` begins with a parse of your program, and so if you input a word that is not a sequence of $\\one\\hash$ expressions, it will stop without further ado.\n", "\n", "The second argument to ```step_by_step``` is a list of words. A list in Python is enclosed by square brackets \\[ and \\], not by parentheses. The words that go in the list are used in R1, R2, . . . in that order. It is understood that any register not represented by any input starts with the empty string. You can also represent the empty string by ' '. And the empty list of registers is denoted by two square brackets with nothing inside, [ ].\n", "\n", "All in all, the examples below show different formats for the input to our function ```step_by_step```.\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": true }, "id": "bQG-Z-2kNzgx", "colab": { "base_uri": "https://localhost:8080/", "height": 530 }, "outputId": "337db8ae-d630-446e-e612-48fc0513a1ff" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "First, here is the program:\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 instructionexplanation
11#add 1 to R1
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "The computation starts with the register contents shown below.\n", "The registers include those those which you entered as part of the input\n", "and also others mentioned in the input program.\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 contents
1#1
2#1
31#
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "Step 1:\n", "Execute instruction 1: add 1 to R1.\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 contents
1#11
2#1
31#
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "This computation does not halt.\n", "Here is the list of registers whose contents are not empty at this point, other than R1:[2, 3].\n", "The register contents at the end are shown above.\n" ] } ], "source": [ "p= '1#'\n", "q = '#1'\n", "step_by_step(p,[q,q,p])" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "jupyter": { "outputs_hidden": true }, "scrolled": true, "id": "T7Xwna4jNzgy", "colab": { "base_uri": "https://localhost:8080/", "height": 629 }, "outputId": "b3ac7818-e4d4-45ac-926a-1638d45eeadb" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "First, here is the program:\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 instructionexplanation
11##add # to R1
211#add 1 to R2
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "The computation starts with the register contents shown below.\n", "The registers include those those which you entered as part of the input\n", "and also others mentioned in the input program.\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 contents
1
2
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "\n", "Step 1:\n", "Execute instruction 1: add # to R1.\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 contents
1#
2
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "Step 2:\n", "Execute instruction 2: add 1 to R2.\n" ] }, { "output_type": "display_data", "data": { "text/plain": [ "" ], "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
 contents
1#
21
\n" ] }, "metadata": {} }, { "output_type": "stream", "name": "stdout", "text": [ "This computation does not halt.\n", "Here is the list of registers whose contents are not empty at this point, other than R1:[2].\n", "The register contents at the end are shown above.\n" ] } ], "source": [ "step_by_step(p+q+p,[])\n", "# This is a comment.\n", "# the symbol + is used for concatenation of strings in Python.\n", "# Since p and q are strings, we can concatenate them" ] }, { "cell_type": "markdown", "metadata": { "collapsed": false, "id": "VKo3wMOqNzgy" }, "source": [ "So far in this notebook, we have only seen the function ```step_by_step```. If we want to run things \"in one fell swoop\", we could use the function ```onesharp(p,[r1,r2, . . ., rn])```. It also takes two arguments, the first a program and the second a (possibly-empty) sequence of input words." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "id": "g_hKkqiUNzgy" }, "outputs": [], "source": [ "clear_1 = '1##### 111### 11#### 111####'\n", "onesharp(clear_1,['1111###1111##########'])\n", "# You can also run the line above slowly by running\n", "# step_by_step(clear_1,['1111###1111##########'])" ] }, { "cell_type": "markdown", "source": [ "" ], "metadata": { "id": "3WeBl5d-3_fJ" } }, { "cell_type": "markdown", "source": [ "# The full set of instructions of 1#\n", "\n", "\n", "| Instruction | Meaning |\n", "| ----------- | ----------- |\n", "| 1^n # | Add 1 to Rn |\n", "| 1^n ## | Add # to Rn |\n", "| 1^n ### | Go forward n instructions |\n", "| 1^n #### | Go backward n instructions |\n", "| 1^n ##### | Cases on Rn |\n", "\n", "All numbers in this chart are written in unary.\n", "Registers are processed as queues: symbols enter on the right and exit on the left.\n", "\n", "The first two types of instructions add symbols to the right ends of the registers.\n", "\n", "Here is a review of how the case instruction ```1^n #####``` works.\n", "\n", "If Rn is empty, we go to the very next instruction.\n", "\n", "If the first symbol of Rn is $\\mathtt{1}$, we delete that symbol and go to the second instruction after the case instruction.\n", "\n", "If the first symbol of Rn is $\\mathtt{\\#}$, we delete that symbol and go to the third instruction after the case instruction.\n" ], "metadata": { "id": "72XoyBfdJqFn" } }, { "cell_type": "markdown", "source": [ "### Useful command-line tools\n", "\n", "These are Python functions which you can call in a code cell, provide that you have run the very first cell in a notebook, the cell that loads in the relevant definitions.\n", "\n", "| Instruction | Meaning |\n", "| ----------- | ----------- |\n", "| ```onesharp(p,[r1, . . .,rn])``` | runs the program ```p``` on the list of words ```[r1, . . .,rn]``` |\n", "| ```step_by_step(p,[r1, . . .,rn])``` | parses p and shows all steps in the run |\n", "| ```parse(p)``` | expresses ```p``` as a list of instructions |\n", "| ```parse_explain(p)``` | gives a table of the parse with glosses |\n", "| ```unparse(p)``` | inverse of ```parse(p)``` |\n" ], "metadata": { "id": "6kV7NJvADpyq" } }, { "cell_type": "markdown", "source": [ "### Useful operations inside a Jupyter notebook\n", "\n", "1. Show the Table of Contents, and also hide it.\n", "\n", "2. Stop a program that is either in an infinite loop or otherwise is going too long.\n", "\n", "3. Insert code cells above or below the current cell.\n", "\n", "4. Insert text cells above or below the current cell.\n", "\n", "5. Add a comment to a cell using # as the first character in a line.\n", "\n", "6. Moving a cell up or down in the notebook.\n", "\n", "7. Delete a cell.\n", "\n", "8. Open a new notebook. " ], "metadata": { "id": "p4rKNF0_6TMh" } }, { "cell_type": "markdown", "source": [ "```{tip}\n", "You need to know the commands of $\\one\\hash$ well to go forward.\n", "\n", "You don't need to know much about Python, but it would help to know the basics of strings and lists. Some exercises will ask you to write Python code, and if you want to solve them you of course would need to know more.\n", "\n", "It would be good to read about the basics of Jupyter notebooks. If you got this far, perhaps you know enough already.\n", "```" ], "metadata": { "id": "3yTAFiDkern_" } } ], "metadata": { "kernelspec": { "display_name": "Python 3 (system-wide)", "language": "python", "metadata": { "cocalc": { "description": "Python 3 programming language", "priority": 100, "url": "https://www.python.org/" } }, "name": "python3", "resource_dir": "/ext/jupyter/kernels/python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" }, "colab": { "provenance": [], "include_colab_link": true } }, "nbformat": 4, "nbformat_minor": 0 }