test-8.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "dda2ce31-2259-4dd0-9388-22c27573e3a7",
   "metadata": {},
   "source": [
    "# answers 00: _Moriarty's game of chaos_\n",
    "\n",
    "Welcome to MCB112, Python, and Jupyter Notebook!\n",
    "\n",
    "The week 0 (\"w00\") pset is an example that gives you a walkthrough of what an MCB112 pset looks like, and a feeling for what we expect an answer to look like. Starting with w01, you'll be turning in your pset answers in the form of a single Jupyter Notebook page (a `.ipynb` file) like this one. Jupyter Notebook allows you to interleave Python code with text, written in Markdown format, a simple markup language for text.\n",
    "\n",
    "This notebook will be way more wordy than you need to be in an answer though, because I'm going to explain a bunch of stuff in a lot of detail, for people who have never seen Python before. I will set these long explanations off in their own _explanations_ sections so they don't interrupt the flow _too_ much.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6cb24c5-bfc7-4740-8128-f0c5ba915a55",
   "metadata": {},
   "source": [
    "## our imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "9146a832-d097-4897-a5e1-30eabda3280b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np                    \n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "%matplotlib inline                     "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fb2f8af-f688-4c87-b18e-2acb30d41b33",
   "metadata": {},
   "source": [
    "## _explanation_\n",
    "\n",
    "This example uses the [NumPy](https://numpy.org/doc/stable/index.html) module for scientific numeric computing, and the [matplotlib](https://matplotlib.org/) module for data visualization. The w01 pset will use only basic python, and you won't need to know or use NumPy or matplotlib until w02.\n",
    "\n",
    "We will also get to the [Pandas](https://pandas.pydata.org/) data analysis module in w03, and some of the [SciPy](https://scipy.org/) module later in the course.\n",
    "\n",
    "For each pset, we'll state which modules you can use. We don't want you to learn to code by googling and finding a bunch of random Python packages. At least not yet. There's a time and place for that, but get your fundamentals down first.\n",
    "\n",
    "The `%matplotlib inline` sets your notebook page so it will render matplotlib figures as (static) images embedded in the notebook page. In fancier notebooks, you can use `%matplotlib widget` (among other options) to use _interactive_ plots. We're not going to do that, at least not for now."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7349be22-041e-446c-ab3c-815cb73a3b77",
   "metadata": {},
   "source": [
    "## 1. \"Write Python code with functions for...\"\n",
    "\n",
    "The pset conveniently suggested one good way of writing modular and reusable code. We can guess that we're going to have sequences that we read from the Genbank files and random sequences that we generate ourself, so we want to separate running the chaos game algorithm on an input sequence from the different ways we might obtain that sequence. It's also useful to separate _generating_ the data from _plotting_ the data, to make our plotting code easier to read, and easier to steal from in the future when we want to make some other kind of 2D scatterplot."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c723741-025b-439c-af1e-9f13d6a1d6e3",
   "metadata": {},
   "source": [
    "###  a) reading one DNA sequence from a Genbank format file\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "1b98e28d-1ca6-4e9a-ad2a-d6f37708866b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_genbank_file(seqfile):\n",
    "    \"\"\"Read one sequence from a Genbank-format file.\n",
    "\n",
    "    Input:  <seqfile>: path to a Genbank format file containing one DNA sequence.\n",
    "    Output: <seq>:     sequence, as a list of upper-case characters (typically A|C|G|T)\n",
    "\n",
    "    If the sequence contains characters other than A|C|G|T, such as degeneracy codes like N|R|Y, these will still be included.\n",
    "    \"\"\"\n",
    "    in_sequence = False\n",
    "    seq         = []\n",
    "    with open(seqfile) as f:\n",
    "        for line in f:\n",
    "            if   line.startswith('//'):     break\n",
    "            elif in_sequence:               seq.extend( [ x.upper() for x in line if x.isalpha() ] )\n",
    "            elif line.startswith('ORIGIN'): in_sequence = True\n",
    "    return seq\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4a43250-12df-4359-a56a-635519736699",
   "metadata": {},
   "source": [
    "### _explanation_\n",
    "\n",
    "If you're new to Python, the tricksiest line in this code was the line with `seq.extend()` on it. Let's dwell on that for a second because we can learn a fair amount of Python all at once.\n",
    "\n",
    "`seq` is a **list**. You can see that because of how we initialize it (`seq = []`). We can look at the documentation for Python lists and see that we can add to them either one item at a time with `append()` or we can add a list of several items at once with `extend()`. Variables in Python (lists, and integers, and floats, and dicts, and whatever) are _objects_ with _methods_: so when we do something like `seq.extend()` we are saying \"invoke the `extend()` method in the `seq` object\", and the stuff in the parentheses is the argument to `extend()`: it will be interpreted as a list. \n",
    "\n",
    "Here, it's a list of the A|C|G|T characters on one line of the GenBank file. You can see us open the file (`open(seqfile) as f`) so that we have an open **file object** `f`, and then we're reading one line at a time from the file in a loop (`for line in f`) in a way where the variable `line` is a **string** containing something like \"1240 ACGTACGATCAG ACGACTGATCTCA\", because lines in Genbank files start with coordinates and also have spaces. We're waiting in the file until the sequence part is about to start (after a line that says 'ORIGIN'), and we stop when there's a line that says '//', by checking `line` with a string method `.startswith()` that tests for exact matching to a query string at the start of `line`. So that's what the `in_sequence` flag is doing: it gets set to `True` when we're in the sequence part of the file.\n",
    "\n",
    "OK, back to the argument to `seq.extend()`, which needs to be a list, but `line` is a string, not a list. We also want to skip the coordinates and the spaces in the line, and only extend `seq` with a list of A|C|G|T characters on `line`. We can iterate over each character in `line` with a for loop: `for x in line`. We could write a few lines of code to initialize a new list, iterate over each character x in `line`, check whether the character is A|C|G|T before we include it, and convert the character to upper case (if it's a lower-case a|c|g|t), but we can do all of this very compactly using something called a **list comprehension**. If we did `[x for x in line]` we would get a list of the characters in `line`. The first `x` there is \"put this thing in the new list...\" and the `for x in line` is \"... for each successive x in line\". We can put anything we want into the new list as we do the `for x in line`, including some sort of operation on `x`: here, we're using the `x.upper()` method to convert `x` to upper case. Finally, Python's list comprehension syntax allows us to append an `if` test for each iteration of the for loop: here, `if x.isalpha()`, where `isalpha()` is a method with no argument that returns True if `x` is an alphabetic character: this is the piece of our code that is skipping spaces and numbers.\n",
    "\n",
    "Whew. Got that?\n",
    "\n",
    "No, it would be easy to still be confused. How should you figure this out as you're learning? The technique I advise to use throughout the course (and indeed throughout life) is, whatever you're trying to understand, create the smallest possible example where you know what the answer is supposed to be, and make sure you can do that first. Then move outwards to more and more complex things, once you've nailed the small things. And in the case of Python: use a lot of print statements when you do it.\n",
    "\n",
    "So here's an example; let's peel apart that list comprehension in a code block of its own in our Markdown, where we can play.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7c53cf44-8eb3-4d23-9be6-ca4eb96e42e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'list'>\n",
      "['1', '2', '0', ' ', 'A', 'C', 'T', ' ', 'g', 'a', 't']\n",
      "['hey!', 'hey!', 'hey!', 'hey!', 'hey!', 'hey!', 'hey!', 'hey!', 'hey!', 'hey!', 'hey!']\n",
      "['1', '2', '0', ' ', 'A', 'C', 'T', ' ', 'G', 'A', 'T']\n",
      "['A', 'C', 'T', 'G', 'A', 'T']\n",
      "['A', 'C', 'T', 'G', 'A', 'T']\n"
     ]
    }
   ],
   "source": [
    "line = '120 ACT gat'                # Forget all the Genbank file stuff. Make sure we can turn this one little line into list('ACTGAT').\n",
    "print( type(line) )                 # The built-in method type() is your friend for figuring out what things are: here, line is a `str` class\n",
    "L    = [x for x in line]            # Simple list comprehension. \n",
    "print( type(L) )                    # The result L is a list of the characters in `line`\n",
    "print (L)      \n",
    "L    = [ 'hey!' for x in line ]     # Nothing sacred about that first x. We can put anything into the new list as we iterate through `line`\n",
    "print (L)\n",
    "L    = [ x.upper() for x in line ]  # but usually it would be something to do with the `x` we're iterating over in line, of course\n",
    "print (L)\n",
    "L    = [ x.upper() for x in line if x.isalpha() ]   # and finally here's what we did to make the argument we passed to `seq.extend()`\n",
    "print (L)\n",
    "L    = list('ACTGAT')               # if it weren't for the numbers and spaces - converting a string to a list is easy with `list()`\n",
    "print (L)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a00f19a2-c35d-47a0-a15f-74f0e5c92796",
   "metadata": {},
   "source": [
    "A notebook cell like that is a (mostly) safe space where you can try different things, run the cell, and see the result quickly. \n",
    "\n",
    "(I say \"mostly\" safe because if you change variables that you're using somewhere else in the notebook, you can break things.)\n",
    "\n",
    "Now back to our regular programming..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1cdabb0-c56b-4d9a-b566-4c7844229645",
   "metadata": {},
   "source": [
    "### b) doing the chaos game algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "2c65234f-a7b0-4afe-a4ba-4caca1fca68c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def chaos_game(seq):\n",
    "    \"\"\"Given a DNA sequence, produce a chaos game representation, as a 2D array of coordinates\n",
    "\n",
    "    Input:  <seq> : a list or array of A|C|G|T characters\n",
    "    Output: 2D numpy array of shape (L x 2): array of 2D coords for each of L points\n",
    "\n",
    "    Assumes that the <seq> list only contains A|C|G|T characters.\n",
    "    \"\"\"\n",
    "    vertices = { 'A' : [0, 0], 'C': [0,1], 'G': [1,1], 'T': [1,0] }\n",
    "    L = len(seq)\n",
    "\n",
    "    data = np.zeros( (L,2) )\n",
    "    data[0] = vertices[seq[0]]\n",
    "    for i in range(1,L):\n",
    "        data[i] = (data[i-1] + vertices[seq[i]]) / 2\n",
    "    return data\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2240fb4d-caaa-4163-a006-25873a49e815",
   "metadata": {},
   "source": [
    "### _explanation_\n",
    "\n",
    "One thing to notice here is that `data[i]` is row `i` of a 2D matrix, so `data[i]` is itself a vector of length 2. Meanwhile we've created `vertices` to be a dict, indexed by the four DNA characters: `vertices['A']` is a vector of length 2, the coords of the 'A' vertex. So when we do `data[i] + vertices[seq[i]]`, we are doing **vector addition**, an example of something that NumPy excels at both in syntax and in internal speed. Add some `type()` and `print()` statements in there to watch it work - or again, create an isolated small example in a new cell:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7fbe2b54-b504-48d6-bc9a-aebcefeaa6cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "(3, 2)\n",
      "<class 'numpy.ndarray'>\n",
      "(2,)\n",
      "<class 'numpy.ndarray'>\n",
      "(2,)\n",
      "[0.7 0.7]\n"
     ]
    }
   ],
   "source": [
    "D = np.array( [ [0.1, 0.1 ],       # Make a small example of the Lx2 array\n",
    "                [0.2, 0.2 ], \n",
    "                [0.3, 0.3 ] ] )\n",
    "vertex = np.array([0.5, 0.5])     # and an example vertex\n",
    "print(type(D))                    # `D` is a numpy array\n",
    "print(D.shape)                    #   ... of \"shape\" 3x2\n",
    "print(type(D[1]))                 # `D[1]` is one row of the array.. but still just another numpy array\n",
    "print(D[1].shape)                 #   ... now of shape 1x2, but since it's a vector, numpy interprets it as `2,`\n",
    "print(type(vertex))               # `vertex` is also a numpy array\n",
    "print(vertex.shape)               #   ... also of shape `2,`\n",
    "r = D[1] + vertex                 # the two vectors have the same shape, so we can add them, elementwise\n",
    "print (r)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36f35a32-95ee-43d1-a6f9-4137e476cf55",
   "metadata": {},
   "source": [
    "And let's also have a closer look at `vertices`. Are you confused about Python `dict` versus `list` objects? I sure was at first. The key idea is the following:\n",
    "\n",
    "A `list` is an ordered set of `n` elements (of any type) that you index by **position** `0..n-1` in the list: `L[i]` gives you the i'th element in `L`.\n",
    "\n",
    "A `dict` is an unordered set of elements (of any type) that you index by a **string**: `D['A']` gives you the element in `D` that you indexed with key `A`.\n",
    "\n",
    "So I used a dict for `vertices` because I wanted to say `vertices['C']`, looking up the coords for the `C` vertex using `C` itself as the index. \n",
    "\n",
    "Again, play with creating and manipulating lists and dicts in an isolated cell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "16cff3bb-5634-4eda-9986-49ab3f9aea30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "postdoc\n",
      "[10, 20, 30, 40]\n",
      "{'Holmes': 'postdoc', 'Watson': 'student', 'Wiggins': 'Baker Street Irregular'}\n"
     ]
    }
   ],
   "source": [
    "L = [ 10, 20, 30 ]\t\t\t\t\t\t         \t# lists: initialization\n",
    "D = { 'Holmes': 'postdoc', 'Watson': 'student' }  \t# dicts: initialization\n",
    "print(L[1])\n",
    "print(D['Holmes'])\n",
    "L.append(40)                              # append to the end of a list\n",
    "print(L)\n",
    "D['Wiggins'] = 'Baker Street Irregular'   # add element to a dict\n",
    "print(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d4a3de5-f690-43ea-95b2-99040e7ccd41",
   "metadata": {},
   "source": [
    "and again back to our regular programming..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ae7b51b-8697-4be8-86a1-85a921587e3f",
   "metadata": {},
   "source": [
    "### c) plotting the chaos game data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5a7cb2f8-0598-4030-aa55-1f25683a0844",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_chaos(data):\n",
    "    \"\"\"Create a scatterplot figure from an Lx2 array of chaos game points\n",
    "\n",
    "    Input <data>: Lx2 array of coords for L points\n",
    "    Result:       an inline figure in our notebook\n",
    "    \"\"\"\n",
    "    fig, ax = plt.subplots()                                                # Creates Figure, Axes objects to plot in\n",
    "    ax.scatter(data[:,0], data[:,1], s=0.1, marker='.', color='black')      # scatter plot with black points of size 0.1\n",
    "\n",
    "    ax.text(0, 1, 'C', horizontalalignment='right')                         # here we're labeling A,C,G,T vertices\n",
    "    ax.text(1, 1, 'G')\n",
    "    ax.text(0, 0, 'A', verticalalignment='top', horizontalalignment='right')\n",
    "    ax.text(1, 0, 'T', verticalalignment='top')\n",
    "\n",
    "    ax.axis('equal')      # make sure the plot is shown as a square, not a rectangle\n",
    "    ax.set_axis_off()     # turn off everything associated with the axes: tick marks, labels, spines\n",
    "\n",
    "    fig.tight_layout()    # tighten margins, reduce unnecessary white space\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e184c726-83e2-48c9-b4e2-b7486f7f52f7",
   "metadata": {},
   "source": [
    "### _explanation_\n",
    "\n",
    "One thing to notice here: `data[:,0]` is what's called a **slice** of an array. matplotlib (and Pandas) are very column-oriented in how they think about 2D data tables. The scatter plot function `ax.scatter()` expects to get a list/array of `n` x coordinates and a corresponding list of `n` y coordinates for the points it will plot; but our data are in an Lx2 array. `data[:,0]` is the syntax for \"give me all of the rows\" (that's the ':') and give me just column 0 (that's the '0'): i.e., extract the X coords as a single array. `data[:,1]` are the y coords. You know the drill: look up array slicing, make a small example in an isolated cell, and play with lots of print statements.\n",
    "\n",
    "matplotlib is big and complicated and I won't say much about it for now; best to start with their tutorial, to understand the syntax. But here's one thing to know up front. There are two main ways of using matplotlib. In one way, you basically assume that you're just making a simple single figure, and you directly call matplotlib functions with `plt.` prefixes, like `plt.plot()`. The other way is \"object oriented\", where you create and manipulate Figure and Axes objects. That's what I'm doing here: creating a Figure and Axes object for my figure with `fig, ax = plt.subplots`, and then using object-oriented methods calls on those objects with things like `ax.scatter()` to create and design my plot. I recommend following this pattern and using the object-oriented style, becuse it's easier to control in something like a jupyter notebook where you have lots of figures at once. I _don't_ recommend mixing the two styles, which is what you will get if you learn matplotlib by googling StackOverflow.\n",
    "\n",
    "OK, enough with the code explanations. We can proceed with the biology now."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa1a634d-ade7-4c9f-9447-4aa9eab67014",
   "metadata": {},
   "source": [
    "## 2. Reproduce Moriarty's three phage results\n",
    "\n",
    "I've downloaded the Genbank files `BabyGotBac.gb`, `Dwayne.gb`, and `Tiamoceli.gb` into the same directory as my Jupyter notebook, so the notebook can find them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c1bb3f01-199e-438f-9918-563aba1fa7b6",
   "metadata": {},
   "source": [
    "### BabyGotBac"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81a3ae57-d68f-46bc-b540-b7626430f3d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = read_genbank_file('BabyGotBac.gb')\n",
    "D   = chaos_game(seq)\n",
    "plot_chaos(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc72259d-f008-48a6-84f1-629a9abbe690",
   "metadata": {},
   "source": [
    "#### Dwayne"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "445ce0f1-0468-48b3-8e4c-88d80fdc41b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = read_genbank_file('Dwayne.gb')\n",
    "D   = chaos_game(seq)\n",
    "plot_chaos(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d0a7ec8-d031-4058-8621-ba0333f6d6c1",
   "metadata": {},
   "source": [
    "### Tiamoceli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "233cf350-270e-4f2a-831b-00f45f5083b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = read_genbank_file('Tiamoceli.gb')\n",
    "D   = chaos_game(seq)\n",
    "plot_chaos(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7618af2d-b6c0-43f5-8483-27b46bc3d530",
   "metadata": {},
   "source": [
    "OK, we've reproduced Moriarty's plots. Now to figure out what's making these cool patterns."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3e34fdd-fdbc-401c-abf6-612f54066b79",
   "metadata": {},
   "source": [
    "## 3. Figure out what determines these patterns, using synthetic random DNA sequences as tests"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d65e63d6-f0cf-42ff-82d1-e0011d3247a3",
   "metadata": {},
   "source": [
    "Those controls we glimpsed on Moriarty's screen were a big clue. What happens if we leave out one of the four nucleotides? Let's generate a sequence consisting only of, say, A|C|T, leaving out G:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24a20e59-cba0-49e2-a285-4e35241c944b",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = np.random.choice(list('ACT'), size=(50000))\n",
    "D   = chaos_game(seq)\n",
    "plot_chaos(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df679cfa-2c95-43ab-a854-86927f3ac9fc",
   "metadata": {},
   "source": [
    "That might seem a little puzzling at first until you realize those aren't blank triangles per se; they are a recursive pattern made out of smaller and smaller empty squares. The upper right \"G\" quadrant is all blank. The upper right subquadrant of all the other quadrants is also blank. And so on down infinitum. \n",
    "\n",
    "Change which nucleotide you leave out and re-run the cell. The blank quadrant is always the missing nucleotide."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68991209-e61e-4f31-8872-94324a57c8f4",
   "metadata": {},
   "source": [
    "Moriarty's other control was to make a DNA sequence that's missing a _di_nucleotide. He chose the CG dinucleotide because it's famously strongly depleted in many genomes, including the human genome. (People call the dinucleotide \"CpG\", emphasizing the phosphate covalent linkage in the DNA strand with that \"p\", to distinguish CpG content from G+C% single base composition.)\n",
    "\n",
    "You can't just sample a DNA sequence 2 nucleotides at a time to eliminate CpG (by which I mean, make the DNA in steps of 2, from 15 of the 16 dinucleotides), because you'll make CpG's at the junctions - for example AC followed by GT creates a CG. You have to be a little more clever. One way is to use a _Markov model_ -- specifically, a first order Markov model, where \"first order\" means the nucleotide $x_i$ we generate depends on _one_ previous nucleotide $x_{i-1}$. A 2nd order Markov model would generate $x_i$ conditional on _two_ previous nucleotides $x_{i-2}, x_{i-1}$, and so on. We parameterize a 1st order Markov model with a 4x4 table of probabilities $P(a | b)$, for the probability of each base $a$ when it follows a context of each previous base $b$. (We'll learn more about probability notation in week 02, and about Markov models in week 05.)\n",
    "\n",
    "So here's an example of generating random DNA from a 1st order Markov model where I've hand-set the parameters:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "091f1eff-61d3-4ff1-8a52-09bdd57a1976",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = [ [ 0.25, 0.25, 0.25, 0.25 ],   # P(x | A), where x = {A,C,G,T}.\n",
    "      [ 1/3,  1/3,  0.0,  1/3  ],   # P(x | C) ... here I've set P(G|C) = 0 to disallow CpG dinucs\n",
    "      [ 0.25, 0.25, 0.25, 0.25 ],   # and so on\n",
    "      [ 0.25, 0.25, 0.25, 0.25 ],\n",
    "    ]\n",
    "alphabet = list('ACGT')\n",
    "L        = 50000\n",
    "\n",
    "seq = ['A']   # I could've been more random about choosing the initial nucleotide... but let's just make it an A,\n",
    "prv = 0       # it doesn't matter for this visualization, the other 49,999 points dominate the view\n",
    "for i in range(1,L):\n",
    "    cur = np.random.choice(4, p=p[prv])     # The p= optional argument to np.random.choice() lets me provide my own probabilities\n",
    "    seq.append(alphabet[cur])               # <cur>, <prv> are integers 0..3, so I have to convert to an A|C|G|T letter with alphabet[cur]\n",
    "    prv = cur\n",
    "\n",
    "D = chaos_game(seq)\n",
    "plot_chaos(D)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "303e6698-998a-4361-908c-fb46b6df00ee",
   "metadata": {},
   "source": [
    "The biggest square that's missing is the upper left subquadrant of the upper right quadrant. We just saw that if our sequence doesn't have any G's in it, it has no points in the upper right \"G\" quadrant. Now we see that if our sequence doesn't have any CpG's in it, it has no points in the upper left \"C\" subquadrant of the upper right \"G\" quadrant.\n",
    "\n",
    "We're starting to get the picture. The squares of different sizes correspond to subsequences of different lengths (\"k-mers\", of different lengths k), and the position of the square corresponds to which k-mer it is.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ec0ba5f-fd31-476f-85dc-ac3cb67c4ec1",
   "metadata": {},
   "source": [
    "OK, what happens when we generate a sequence that's missing a particular 4-mer? \n",
    "\n",
    "Here's a really cheapo, quick and dirty way to do it... which happens to help us learn a little Python about how to edit lists. We'll generate a uniformly random sequence, but then sweep through the sequence and replace every occurrence of the kmer-to-eliminate with another sequence - carefully choosing that sequence so it can't accidentally create the kmer at the junctions of the sequences around it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0039727-1579-4ba3-afce-cca3b37469c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "kmer     = list('CCAG')\n",
    "new_kmer = list('TTTT')\n",
    "k        = len(kmer)\n",
    "L        = 50000\n",
    "seq      = list(np.random.choice(list('ACGT'), size=(50000)))\n",
    "\n",
    "for i in range(L-k+1):\n",
    "    if seq[i:i+4] == kmer: seq[i:i+4] = new_kmer\n",
    "\n",
    "D = chaos_game(seq)\n",
    "plot_chaos(D)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa600e8b-bbae-4d30-9fe8-f59d577a9f90",
   "metadata": {},
   "source": [
    "That's informative. \"CCAG\" is in the upper right G quadrant, lower right A subquadrant, upper right C sub-subquadrant, upper right C sub-sub-quadrant, in a little square of $\\frac{1}{4}^4$ area: that square is blank. And so are smaller squares corresponding to the 5-mers ACCAG, CCCAG, GCCAG, TCCAG that end in CCAG. And so on recursively.\n",
    "\n",
    "We can also see that we caused extra darkening around the T vertex because we created a bunch of extra T-rich k-mers with our dumb trick of replacing CCAG with TTTT.\n",
    "\n",
    "The idea that the chaos game is a recursive representation of the k-mer composition of the sequence, for all lengths k at once, is illustrated here (in a figure taken from Goldman (1993); full reference and link at the end of the notes):"
   ]
  },
  {
   "attachments": {
    "fd9d92f0-cd1e-456b-af63-3a7e25e8f3c6.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "fe8c2b66-93da-432c-837c-200f8d36405c",
   "metadata": {},
   "source": [
    "![Screenshot 2024-09-02 at 5.57.48 PM.png](attachment:fd9d92f0-cd1e-456b-af63-3a7e25e8f3c6.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33ba0c62-7add-4c65-9fe7-864457588a25",
   "metadata": {},
   "source": [
    "Just to beat a dead horse, while learning a little more Python... let's create a sequence that consists of _only_ repeats of CCAG. We expect this to have four different 4-mers, because of overlaps: CCAG, CAGC, AGCC, and GCCA. And if you think about it, there's only four different 5-mers too (CCAGC, CAGCC, AGCCA, GCCAG), and so on... so if we're right, we expect to get a chaos game representation that has just four spots in it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6328b0e-10b2-444e-bc9e-9074dd3d4c38",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = list('CCAG') * 10000\n",
    "D = chaos_game(seq)\n",
    "plot_chaos(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b5f2bed-80e1-4c7c-9499-84ce61bc560b",
   "metadata": {},
   "source": [
    "Yup, four points, and in the right places if we stare at them long enough. Empirically anyway, I think we can call it a day. \n",
    "\n",
    "Can we prove it? Mathematically, how does it work?\n",
    "\n",
    "Suppose our last point was at coordinates $(x_{i-1}, y_{i-1})$ and the next base $s_i$ is an A, so we're going to move halfway to the $(0,0)$ vertex. We know $x_{i-1}$ must be $ 0 \\leq x_{i-1} \\leq 1 $ (because it's in the square); so when we move halfway toward the $(0,0)$ vertex, the $x_i$ coord now must be $ 0 \\leq x_i \\leq 0.5 $. Same argument holds for $ 0 \\leq y_{i} \\leq 0.5 $. Thus we know that when $s_i$ is A, no matter where the previous point was, our new point $(x_i,y_i)$ must go to the lower left \"A\" quadrant. With some tedious notation, we could then prove this idea recursively for the subquadrants on down."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d67baee-26d6-457c-96d2-b82cc626527a",
   "metadata": {},
   "source": [
    "## 4. Design an experiment to test the idea by randomizing the three phage genomes\n",
    "\n",
    "So a killer experiment is to randomize the genomes preserving k-mer composition (for some choice we make for a small k), so we would be randomizing away any more complex \"hidden language\" in the sequence. \n",
    "\n",
    "It's easy to shuffle the bases in the sequence independently (e.g. for k=1). (Actually, I take that back. There are a bunch of ways to shuffle a sequence that are subtly wrong and don't get you a uniformly random shuffle. For the right algorithm, look up the [Fisher-Yates algorithm](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle). If you use something like `np.random.shuffle()`, that's what it's doing.) It's harder to shuffle in a way that exactly preserves dinucleotide composition; the algorithm for that is called Altschul-Erickson. It can be extended to higher orders if needed.\n",
    "\n",
    "For our purposes we don't need an exact shuffle; to make the point, we can use an approximation, and generate DNA sequences that have the same k-mer composition probabilities. We've already seen a 1st order Markov model above, which models dinucleotide composition statistics. So for modeling k-mer composition for arbitrary k, we want a k-1'th order Markov model. If we want to show that the chaos game patterns are almost entirely explicable in terms of 3-mer or 4-mer statistics, we can generate randomized DNA sequence from a 2nd or 3rd order Markov model, parameterized with the composition statistics of the original Genbank sequences.\n",
    "\n",
    "But if I showed you code for doing that, then I'd give away too much of the week 05 pset, where we're going to learn about Markov models! So I'm going to cheat. As Julia Child would say, here's some randomized DNA sequences I prepared earlier. Download these four files to your directory:\n",
    "\n",
    "* [BabyGotBac.shuf-k3](http://mcb112.org/w00/BabyGotBac.shuf-k3)   DNA sequence generated with 3-mer statistics of BabyGotBac, using a 2nd order Markov model\n",
    "* [Dwayne.shuf-k3](http://mcb112.org/w00/Dwayne.shuf-k3)     ... and Dwayne, randomized preserving statistical 3-mer composition\n",
    "* [Tiamoceli.shuf-k3](http://mcb112.org/w00/Tiamoceli.shuf-k3)  ... and Tiamoceli\n",
    "* [BabyGotBac.shuf-k4](http://mcb112.org/w00/BabyGotBac.shuf-k4)  ... and BabyGotBac again but preserving 4-mer statistics\n",
    "\n",
    "And now let's see their chaos game plots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "902bdc48-d48b-429b-902e-d680a5582bd8",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = read_genbank_file('Dwayne.shuf-k3')\n",
    "D   = chaos_game(seq)\n",
    "plot_chaos(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65da2f54-11cc-493f-bc65-fef89be0fbd4",
   "metadata": {},
   "source": [
    "First up is Dwayne, with its strong horizontal striping... which is pretty much exactly reproduced using the randomized DNA sequence with its 3-mer statistics. For whatever reason, phage Dwayne is avoiding all of the 3-mers that are all A+T: it is strongly depleted for AAA, ATA, ATT, TTA, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "508e1162-bb83-40f6-a847-693b26e20bad",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = read_genbank_file('Tiamoceli.shuf-k3')\n",
    "D   = chaos_game(seq)\n",
    "plot_chaos(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aa9910b-1c58-4213-9ea2-e7f7ec34ecd6",
   "metadata": {},
   "source": [
    "Next we have Tiamoceli, with its X patterns - also pretty much exactly reproduced from its 3-mer statistics. I'm not sure exactly what's going on here; it's worth doing a little more work. I think it's avoiding polypyrimidine and polypurine runs: sequences like CTCTCTCTC and AGAGAGAGA, that would put kmers along the diagonal of the chaos plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d459dc8-f667-4330-91ae-7d9ea68627b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = read_genbank_file('BabyGotBac.shuf-k3')\n",
    "D   = chaos_game(seq)\n",
    "plot_chaos(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89af0242-fe3c-4d69-8d32-8e138cb1a59b",
   "metadata": {},
   "source": [
    "And finally BabyGotBac. This isn't quite the same pattern! BabyGotBac has two prominent strongly-depleted squares that (according to our hypothesis) correspond to missing 4-mers, not 3-mers; specifically, the two most striking holes correspond to missing GGAG and its reverse complement CTCC. So that suggests we need to look at a 4-mer composition-preserving randomization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f05331a4-b163-4179-99a6-7da5ecbaf232",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = read_genbank_file('BabyGotBac.shuf-k4')\n",
    "D   = chaos_game(seq)\n",
    "plot_chaos(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23b0467c-c519-472c-b39d-b8913ddde407",
   "metadata": {},
   "source": [
    "and indeed now those holes appear. Just to put the original plot up again for comparison:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14c95f37-fe70-4e87-8df3-4b7c496b6716",
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = read_genbank_file('BabyGotBac.gb')\n",
    "D   = chaos_game(seq)\n",
    "plot_chaos(D)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d318c4a1-286c-4955-ac11-f3f61257b5bb",
   "metadata": {},
   "source": [
    "## Summary\n",
    "\n",
    "The \"chaos game representation\" is a recursive representation of the k-mer composition of the sequence, for all lengths k at once. Each k-mer is represented by a subsquare, with longer k-mers represented in smaller squares."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e579236-615d-4705-98ae-c034979afa6d",
   "metadata": {},
   "source": [
    "## _Further reading_\n",
    "\n",
    "The chaos game is for real!  Two papers in the early 1990's introduced the chaos game representation of DNA sequences without fully understanding what was making all the interesting patterns, and then a paper by Nick Goldman showed what was going on, primarily by using sequence randomizations like the ones above. \n",
    "\n",
    "* H.J. Jeffrey, [\"Chaos game representation of gene structure\"](https://doi.org/10.1093/nar/18.8.2163), Nucl. Acids Res. 18:2163-2170 (1990).\n",
    "* H.J. Jeffrey, [\"Chaos game visualization of sequences\"](https://doi.org/10.1016/0097-8493(92)90067-6), Comput. & Graphics 16:25-33 (1992).\n",
    "* N. Goldman, [\"Nucleotide, dinucleotide and trinucleotide frequencies explain patterns observed in chaos game representations of DNA sequences\"](https://doi.org/10.1093/nar/21.10.2487), Nucl. Acids Res. 21:2487-2491 (1993).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76661518-d086-4e36-b72d-9e956a8da7e3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}