Lec_04_Defining_Computation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# CS 121 Lecture 4 : Defining computation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "%%html\n",
    "<style>\n",
    "\n",
    ".CodeMirror {\n",
    "    width: 100vw;\n",
    "}\n",
    "S\n",
    ".container {\n",
    "    width: 99% !important;\n",
    "}\n",
    "\n",
    ".rendered_html {\n",
    "  font-size:0.8em;\n",
    "}\n",
    ".rendered_html table, .rendered_html th, .rendered_html tr, .rendered_html td {\n",
    "     font-size: 100%;\n",
    "}\n",
    "\n",
    "td {\n",
    "  font-size: 50px\n",
    "}\n",
    "</style>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def AND(a,b): return a*b\n",
    "\n",
    "def OR(a,b): return 1 if a+b else 0\n",
    "\n",
    "def NOT(a): return 1-a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Q:__ Compute $f:\\{0,1\\}^3 \\rightarrow \\{0,1\\}$ s.t.\n",
    "$$f(a,b,c) = \\begin{cases}b & a=1 \\\\ c & a =0 \\end{cases}$$\n",
    "using $AND$, $OR$, and $NOT$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "__Solution:__    $f(a,b,c) = (a \\wedge b) \\vee (\\neg a \\wedge c)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# (a ∧ b) ∨ (¬a ∧ c)\n",
    "C = circuit(lambda a,b,c: OR( AND(a,b) , AND( NOT(a),c ) ) )\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "C(0,0,1, render = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "table(C)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "print(circuit2prog(C))\n",
    "C.draw()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Def I (3.5):__ <font color=\"red\">_Boolean Circuit_</font> $C$ is a DAG where vertices  \n",
    "are <font color=\"blue\">_inputs_</font> labeled   `X[0]` ... `X[n-1]` or <font color=\"blue\">_gates_</font>\n",
    "labeled  $\\wedge$/$\\vee$/$\\neg$.\n",
    "<font color=\"blue\">_Output gates_</font> are additionally labeled with  `Y[0]` ... `Y[m-1]`.<br>\n",
    "For $x\\in \\{0,1\\}^n$,  we denote the output of $C$ on input $x$ by $C(x)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "__Def II (3.7):__ <font color=\"red\">_AON-CIRC program_</font> $P$ has lines of form\n",
    "`foo = AND(bar,blah)` , `foo = OR(bar,blah)` or `foo = NOT(blah)`. \n",
    "<font color=\"blue\">_Input variables_</font> are named  `X[0]`,...,`X[n-1]`and \n",
    "<font color=\"blue\">_output variables_</font> are named  `Y[0]`..`Y[m-1]`. <br>\n",
    "For $x\\in \\{0,1\\}^n$, we denote the output of $P$ on input $x$ by $P(x)$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Theorem III (3.8):__ For every $f:\\{0,1\\}^n \\rightarrow \\{0,1\\}^m$ and $s\\in \\mathbb{N}$, \n",
    "$f$ is computable by a Boolean circuit of $s$ gates if and only if \n",
    "$f$ is computable by an AON-CIRC program of $s$ lines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def EVAL(code,X):\n",
    "    \"\"\"Evaluate code on input X.\"\"\"\n",
    "    n,m = numinout(code) # helper function - get number of inputs and outputs\n",
    "    \n",
    "    vtable = { f\"X[{i}]\":int(X[i]) for i in range(n)}\n",
    "    \n",
    "    for line in code.split(\"\\n\"):\n",
    "        if not line: continue\n",
    "        foo,op,bar,blah = parseline(line,2) \n",
    "        # helper function - split \"foo = OP(,blah)\" to list [\"foo\",\"OP\",\"bar\",\"blah\"]\n",
    "        # 2 is num of arguments to expect: blah is empty if it's missing\n",
    "        if op==\"NOT\": vtable[foo] = NOT(vtable[bar])\n",
    "        if op==\"AND\": vtable[foo] = AND(vtable[bar],vtable[blah])\n",
    "        if op==\"OR\": vtable[foo] =  OR(vtable[bar],vtable[blah])\n",
    "    \n",
    "    return [vtable[f\"Y[{j}]\"] for j in range(m)]            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Q:__ Write an AON-CIRC program that computes $XOR:\\{0,1\\}^2 \\rightarrow \\{0,1\\}$ where $XOR(a,b) = a+b \\mod 2$\n",
    "\n",
    "code = r'''\n",
    "foo = AND(X[0],X[1])\n",
    "bar = NOT(foo)\n",
    "or  = OR(X[0],X[1])\n",
    "Y[0] = OR(foo,OR)'''[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "xorcode = r\"\"\"\n",
    "t1      = AND(X[0],X[1])\n",
    "nott1   = NOT(t1)\n",
    "t2      = OR(X[0],X[1])\n",
    "Y[0]    = AND(nott1,t2)\n",
    "\"\"\"[1:]\n",
    "table(xorcode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "circuit(xorcode)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Back to powerpoint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Q:__ Write NAND-CIRC code to compute $XOR:\\{0,1\\}^2 \\rightarrow \\{0,1\\}$ such that $XOR(a,b) = a+b \\mod 2$.\n",
    "\n",
    "Reminder AON-CIRC code is:\n",
    "```python\n",
    "t1      = AND(X[0],X[1])\n",
    "nott1   = NOT(t1)\n",
    "t2      = OR(X[0],X[1])\n",
    "Y[0]    = AND(nott1,t2)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def parseline(line, numargs = 2):\n",
    "    \"\"\"Parse a line of the form foo = 'OP( bar1, bar2, bar3)'\n",
    "       to ['foo','OP','bar1','bar2','bar2'].\n",
    "       If numargs > number of arguments in line then add empty strings to the list as needed.\"\"\"\n",
    "    if not line: return [\"\"]*(2+numargs)\n",
    "    i = line.find(\"=\")\n",
    "    j = line.find(\"(\")\n",
    "    k = line.find(\")\")\n",
    "    if i<0 or j<0 or k<0: raise Exception(f\"Line not formatted properly: {line}\")\n",
    "    args = [a.strip() for a in line[j+1:k].split(\",\")]\n",
    "    if len(args)<numargs: args += [\"\"]*(numargs-len(args))\n",
    "    return [line[:i].strip() , line[i+1:j].strip()] + args"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def AON2NAND(code):\n",
    "    output = \"\"; counter = 0\n",
    "    for line in code.split(\"\\n\"):\n",
    "        foo,op,bar,blah = parseline(line) \n",
    "        # helper: parses \"foo = op(bar,blah)\"\n",
    "        if op==\"NOT\":\n",
    "            output += f\"{foo} = NAND({bar},{bar})\\n\"\n",
    "        if op==\"AND\": \n",
    "            output += f\"temp_{counter} = NAND({bar},{blah})\\n\"\n",
    "            output += f\"{foo} = NAND(temp_{counter},temp_{counter})\\n\"\n",
    "            counter +=1\n",
    "        if op==\"OR\":\n",
    "            output += f\"temp_{counter} = NAND({bar},{bar})\\n\"\n",
    "            output += f\"temp_{counter+1} = NAND({blah},{blah})\\n\"\n",
    "            output += f\"{foo} = NAND(temp_{counter},temp_{counter+1})\\n\"\n",
    "            counter +=2\n",
    "    return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "xornand = AON2NAND(xorcode)\n",
    "print(xornand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "circuit(xornand).draw()\n",
    "table(xornand)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "# Q: what does this program compute?\n",
    "mystery='''\n",
    "u = NAND(X[0],X[1])\n",
    "v = NAND(X[0],u)\n",
    "w = NAND(X[1],u) \n",
    "Y[0] = NAND(v,w)'''[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "table(mystery)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "circuit(mystery)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "__Q:__ Design a NAND circuit to compute $XOR4:\\{0,1\\}^4 \\rightarrow \\{0,1\\}$ where $XOR4(a,b,c,d) = a+b+c+d \\mod 2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "def XOR2(a,b):\n",
    "    u = NAND(a,b)\n",
    "    v = NAND(a,u)\n",
    "    w = NAND(b,u)\n",
    "    return NAND(v,w)\n",
    "\n",
    "def XOR4(a,b,c,d):\n",
    "    u = XOR2(a,b)\n",
    "    v = XOR2(c,d)\n",
    "    return XOR2(u,v)\n",
    "\n",
    "XOR4circ = circuit(XOR4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "XOR4circ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "table(XOR4circ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "print(circuit2prog(XOR4circ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Next Up:\n",
    "\n",
    "__Theorem:__ For _every_ function $f:\\{0,1\\}^n \\rightarrow \\{0,1\\}^m$ there exists a Boolean circuit to compute $f$.\n",
    "\n",
    "__Corollary:__ For every such $f$, there is AON-CIRC program/NAND circuit/NAND-CIRC program to compute $f$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "![](pizzaparty.png)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "tcs",
   "language": "python",
   "name": "tcs"
  },
  "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}