1)Introducing Phosphorus.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducing Phosphorus\n",
    "\n",
    "### Introducing Jupyter\n",
    "\n",
    "This course software is running on [Jupyter](https://jupyter.org/), with a special extension called \"phosphorus\". Jupyter notebooks are a series of cells, such as this one, which contains specially formatted text called [Markdown](https://www.ibm.com/docs/en/watson-studio-local/1.2.3?topic=notebooks-markdown-jupyter-cheatsheet), and the next one, which allows computer code. \n",
    "\n",
    "You can click on a cell to edit its contents, and hit Ctrl-Enter (or ⌘-Enter on Mac) to run the cell. Shift-Enter runs the cell and moves to the next one. Code cells, like the next one, run the python programming language. The first two lines, starting with \"#\" are comments: everything from the \"#\" to the end of the line is ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is a python language cell\n",
    "# click here and then hit Ctrl-Enter to run the code\n",
    "1+2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading Phosphorus, Numbers, Sets, & Lists\n",
    "\n",
    "The semantics-specific code requires a special jupyter extension, called phosphorus, which allows certain expressions not normally allowed in python. The following cell loads this extension. You'll know it was loaded when the (frankly awesome) splashscreen appears.\n",
    "\n",
    "**NOTE**: <mark>This step is not needed when running these notebooks via Binder</mark> (url begins `mybinder.org`). Uncomment the following lines if necessary.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install phosphorus from GitHub, if necessary:\n",
    "#!pip install git+https://github.com/EasyArray/phosphorus#egg=phosphorus\n",
    "\n",
    "# Load phosphorus:\n",
    "# %load_ext phosphorus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Type Information & Numbers\n",
    "Once the code is loaded, any item that is recognized as a phosphorus value will appear with a purple type designation at the righthand side of the output. (Ignore any green type information for now.) \n",
    "\n",
    "For instance, now when we enter numbers, they are marked as such in purple on the right:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Numbers\n",
    "1\n",
    "2\n",
    "1+2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constants\n",
    "Another useful type of value in phosphorus is a *constant*, quite similar to a python *string*. In python, strings must have quotation marks around them, but phosphorus considers any sequence of just letters, numbers, and underscores (**not** starting with a number) a constant:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"abcde\" # a python string\n",
    "abcde   # the same thing as a phosphorus constant\n",
    "a1_b    # another constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constants starting with a number and with other characters (such as spaces) are allowed in phosphorus. They just need to be entered the python way, surrounded by quotes (single or double):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1           # a number\n",
    "\"1\"         # a constant\n",
    "\"^a4&aa324\" # a constant containing special characters\n",
    "\"one two\"   # a constant containing a space"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, constants *evaluate to* (i.e., print out as) their own names (minus any quotes). Later, we will see how constants can also be used as variable, storing different values then their own names.\n",
    "\n",
    "### Tuples and Sets\n",
    "\n",
    "Phosphorus *tuples* and *sets* are values that contain other values. Python distinguishes between tuples, entered using parentheses `( )`, and lists, entered using square brackets `[ ]`, but both are the same in phosphorus. Phosphorus also allows you to enter tuples using angle brackets `⟨ ⟩`, the standard mathematical notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# These three are exactly the same:\n",
    "\n",
    "(3,2,1,3,2,1) # a python style tuple\n",
    "[3,2,1,3,2,1] # a python style list \n",
    "⟨3,2,1,3,2,1⟩ # a phosphorus style tuple \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**Note:** Angle brackets are different from less-than and greater-than signs `< >`. But how do you type them in? Once phosphorus is loaded, you can enter `\\<` (backslash less-than) or `\\>` (backslash greater-than) and then hit `Tab` to type in angle brackets. Give it a try!\n",
    "\n",
    "Sets are entered using curly braces (aka curly brackets) `{ }`, as shown in the following cell. This is the same as in python. Unlike python, though, sets can contain other sets. Questions:\n",
    "\n",
    "🤔 What is the purple type value for tuples? for sets?\n",
    "\n",
    "🤔 What differences do you notice between sets and tuples?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{3,2,1,3,2,1} # a set of numbers\n",
    "\n",
    "{{a,b,c}, {1,2,3}, [d,e,f], 4, 5, 6} # a set with mixed type elements\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trees\n",
    "One more type of value in phosphorus is a syntactic tree. Some examples are given in the next cell. Try running them! Note that while leaf nodes may contain any type of value, parent nodes may only be constants. For fun, you can use a tree emoji 🌲 to introduce a tree. To type it, simply enter `\\tree` and hit tab. \n",
    "\n",
    "**Notes**:\n",
    "* A bug in Jupyter sometimes disables this sort of tab-completion in cells containing unusual characters like this tree emoji.\n",
    "* You can break up trees over multiple lines by using a backslash `\\` at the end of a line to be continued."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree[_S \\\n",
    "     [_NP [_N Jasmine]] \\\n",
    "     [_VP [_V jumped]] \\\n",
    "    ]\n",
    "\n",
    "🌲[Jasmine [ate broccoli]]\n",
    "\n",
    "tree[⟨2,1⟩ {2,1}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Technically, a tree consists of a (possibly empty) *label* and zero or more *children*, which are also trees. Phosphorus trees start with the keyword `tree` followed by square brackets `[ ]`. Then, labels are introduced right after the opening bracket `[` with an undscore `_`. Children are simply included inside the brackets. For instance, the following tree has the label `Label1` and has two children, whose labels are `Label2` and `Label3`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree[_Label1 tree[_Label2 tree[_Label4 ]] tree[_Label3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Of course, this notation gets a little tedious, so we can abbreviate. Only the topmost tree requires the `tree` keyword. Also, if a tree has no children, you can skip the brackets and underscore entirely. Finally, labels are optional. (See examples in the next cell.)\n",
    "\n",
    "**Note:** The positions marked by labels are also known as *nodes* of the tree. The node at the top is known as the *root* node and nodes at the very bottom (without children) are called *leaf* nodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree[_Label1 [_Label2 [_Label4]] [_Label3]] # leaving off tree keywords\n",
    "\n",
    "tree[_Label1 [_Label2 Label4] Label3]       # abbreviating leaf nodes\n",
    "\n",
    "tree[[[]] []]    # a no-label tree"
   ]
  }
 ],
 "metadata": {
  "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}