{
 "metadata": {
  "name": "",
  "signature": "sha256:20880da2712107cdf826fa4ff75a8dd21791a96a23a0e9131caed4e4606ac43a"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Lab3 - Multimedia Lab\n",
      "\n",
      "The Multimedia Lab will be a two part lab designed to discuss each aspect of the life-cycle of a multimedia file. This story begins with generation of the file, which is the digitization of some analog phenomenon of interest (e.g. sound -> music, light -> image, both -> film). Once this process is complete, the generated digital media file can be operated on (stored, read, copied, etc.) by a finite precision computer. Each of these operations, however, would be quite a bit faster if the file were small, so we'll investigate compressing the file into a more compact representation. As the honorable Snoop Dogg knew well, it \"ain't no fun if the homies can't have none,\" so you'll naturally want to share this media file with your friends. We'll look at the complications that may arise in transmission, and investigate techniques to ensure that your friend recieves the file error-free. Sadly, all good things must come to an end, and if your file is stored on some physical medium, it will eventually be corrupted.\n",
      "\n",
      "Naturally, the process of capturing, storing, transmitting, and eventually deleting a media file is composed of a harmony of instruments across **all** EECS disciplines, but this lab will focus in particular on the role of probabilistic analysis, reasoning, and algorithm design in this symphony. Probability in EECS does not exist in a vacuum but, as you will see in this lab, often forms the theoretical underpinning to analyze the efficacy of an idea.\n",
      "\n",
      "This notebook covers Part 1 of the lab, in which we'll cover the first half of this process: digitization and compression of media. Next week, Part 2 of the lab will be assigned, which covers transmission and corruption. Hope you enjoy the lab!"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Part 1: Quantization and Huffman Compression\n",
      "\n",
      "When capturing media, we must go from a real world analog media to a digital representation. In general, this process is a matter of sampling, quantization, and compression. As technology improves, sampling methods become faster and more precise, quantized representations of media allow for more bits of precision, and both lossy and lossless compression algorithms improve performance. The tools to measure the effectiveness of these improving technologies, however, remain largely the same, and many of them are built on probabilistic analysis.\n",
      "\n",
      "In this lab, we will talk about quantization for audio signals, and compression of tweets. This should give you an introduction to two of the key aspects of digitally storing analog media."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Audio Quantization \n",
      "\n",
      "We live in an analog world, where input values may be continous and uncountable. This isn't very useful if we want to do any sort of digital signal processing. What we do instead to deal with this is to create a mapping from our huge set of continuous input values, to a smaller set that we can manage. We essentially bucket-off all of our input values before working with them (rounding is a form of quantization as well). However, as you might imagine, by mapping a large set to a smaller one, we introduce some level of quantization error (think integer division in python). The amount of distortion you experience will be determined by the method and parameters used during the quantization process. \n",
      "\n",
      "In this portion of the lab, we will step you through the process of generating and playing a wav file in iPython. You will then implement a quantizer method, and play the resulting quantized song. We will wrap up this section of the lab by exploring the effects of quantization error.\n",
      "\n",
      "The following modules and functions will allow you to generate, load, and play a wav file in iPython. You don't need to understand how they work, but you should understand how to use them."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import scipy.constants as const\n",
      "import scipy\n",
      "from scipy.io import wavfile\n",
      "from IPython.core.display import HTML\n",
      "from IPython.display import display\n",
      "import numpy as np\n",
      "import matplotlib.pyplot as plt\n",
      "from __future__ import division\n",
      "%matplotlib inline\n",
      "\n",
      "# this is a wrapper that take a filename and publish an html <audio> tag to listen to it\n",
      "def wavPlayer(filepath):\n",
      "    src = \"\"\"\n",
      "    <head>\n",
      "    <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">\n",
      "    <title>Simple Test</title>\n",
      "    </head>\n",
      "    \n",
      "    <body>\n",
      "    <audio controls=\"controls\" style=\"width:600px\" >\n",
      "      <source src=\"files/%s\" type=\"audio/wav\" />\n",
      "      Your browser does not support the audio element.\n",
      "    </audio>\n",
      "    </body>\n",
      "    \"\"\"%(filepath)\n",
      "    display(HTML(src))\n",
      "    \n",
      "def playMusic(title, rate, music):\n",
      "    # write the file on disk, and show in in a Html 5 audio player\n",
      "    music_wav = music * 2**13\n",
      "    wavfile.write(title + '.wav', rate, music_wav.astype(np.int16))\n",
      "    wavPlayer(title + '.wav')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Generating a Song\n",
      "\n",
      "Each key of a piano can be thought as a sinusoidal wave with a certain frequency. Let us consider the following score of a song, 'School Bell Ringing'. \n",
      "<center><img src=\"http://i.imgur.com/yDS60eM.png\" alt=\"School bell notes\"></center>\n",
      "\n",
      "Let us assume that each note is a half second long sinusoidal wave. Because the song consists of 32 notes, the song is 16 seconds long. If we specify a sampling rate of 44.1 kHz, then our song will have $44100\\times16$ samples in the entire song. The frequency associated with each note will be specified by the formula given for <a href=\"http://en.wikipedia.org/wiki/Piano_key_frequencies\">piano key frequencies</a>, namely that the frequency for the $n^\\text{th}$ key is given by\n",
      "\n",
      "\n",
      "$$ {\\huge f(n) = 2^{\\frac{n-49}{12}}\\times 440 \\text{Hz} }$$\n",
      "\n",
      "The list $\\operatorname{notes}$ specified below holds the key values $n$ for each note in 'School Bell Ringing' in sequential order."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# C:40, D:42, E:44, F:45, G:47, A:49, B:51, Higher C:52\n",
      "# 0 represents 'pause'\n",
      "notes = [47, 47, 49, 49, 47, 47, 44, 44, 47, 47, 44, 44, 42, 42, 42, 0,\n",
      "         47, 47, 49, 49, 47, 47, 44, 44, 47, 44, 42, 44, 40, 40, 40, 0]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "From these $n$ values, we can generate the sinusoids which represent this song as follows:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "note_duration = 0.5 # per key, in sec\n",
      "rate = 44100 #44.1 khz\n",
      "music_duration = note_duration * len(notes)\n",
      "time = np.linspace(0, music_duration, num=rate*music_duration) # indices for 0-16 secs spaced apart by 1/44100\n",
      "song = np.zeros(len(time))\n",
      "\n",
      "sinwave = lambda f,t : np.sin(2*np.pi*f*t) # generate a sinusoid of frequency f Hz over time t\n",
      "key2freq = lambda n : 2 ** ((n-49)/12) * 440 # convert a piano key n to a frequency in Hz\n",
      "\n",
      "idx_note = 0\n",
      "for note in notes:\n",
      "    if note: # if note == 0, skip.\n",
      "        freq = key2freq(note) # frequency of each note\n",
      "        song[idx_note*rate*note_duration : (idx_note+1)*rate*note_duration-1] = \\\n",
      "                sinwave( freq,\n",
      "                        time[idx_note*rate*note_duration : (idx_note+1)*rate*note_duration-1 ] \n",
      "                        ) #generates the sinusoids for the song, in .5 sec intervals\n",
      "    idx_note += 1"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Now that we've generated the song, let's plot the first 0.01 seconds to see that we actually turned notes into sinusoidal waves."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "plt.plot(time[0:441], song[0:441]) # Plot the first 0.01 second\n",
      "plt.title(\"First 0.01 seconds of 'School Bell Ringing'\")\n",
      "plt.xlabel(\"Time\")\n",
      "plt.ylabel(\"Amplitude\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "And now, let's listen to the song that's been generated."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "playMusic('school_bell_original', rate, song)\n",
      "print \"Wow! What a great song. I should try playing other ones too.\""
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## <font color=blue> Q1. Quantize the song</font>\n",
      "Now for the fun part. We want to quantize this audio signal and analyze the resulting error. We will use an $\\ell$-bit uniform-quantizer. We can use only $L = 2^\\ell$ quantized values: $\\{-1, -\\frac{L-3}{L-1}, -\\frac{L-5}{L-1}, ..., -\\frac{1}{L-1}, \\frac{1}{L-1}, ..., \\frac{L-5}{L-1}, \\frac{L-3}{L-1}, 1\\}$ to represent each value of the original signal $-1 \\leq x[n] \\leq 1$. Our signal only takes values between -1 and 1, so our $\\ell$-bit uniform-quantizer allows our signal to take on $2^\\ell$ evenly spaced values in the range of interest. Each point in the original signal $x[n]$ is binned according to a nearest neighbor strategy.\n",
      "\n",
      "### <font color=blue>a. Implement the quantizer method below, under the above conditions.</font>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def quantizer(num_of_bits, original_signal):\n",
      "    # Complete this quantizer method.\n",
      "    # It should return a numpy array of the same length that contains quantized values of the original signal.\n",
      "\n",
      "    # your beautiful code here... #\n",
      "    \n",
      "    return quantized_signal"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### <font color=blue>b. What do you expect the quantized signal to look like if <tt> number_of_bits </tt> is set to 1?</font>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "1b. Your Answer Here"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### <font color=blue>c. Quantize the song using your quantizer.Plot and compare the original signal and the quantized signal. Play around with `num_of_bits` to see how the song changes</font>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "num_of_bits = 4\n",
      "quantized_song = quantizer(num_of_bits,song)\n",
      "# Plot the first 0.01 second of songs.\n",
      "plt.figure(figsize=(10,6))\n",
      "plt.plot(time[0:441], song[0:441])\n",
      "plt.plot(time[0:441], quantized_song[0:441])\n",
      "plt.legend(['Original Signal', 'Quantized Signal'])\n",
      "plt.title('Effects of ' + str(num_of_bits) + '-bit quantizer')\n",
      "\n",
      "playMusic('quantized_song_' + str(num_of_bits) + '_bits', rate, quantized_song)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "____"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "As noted before, the difference you are witnessing between the original signal and the quantized signal is the <b>quantization \n",
      "error</b>. As confirmed from the previous exercise, the quantization noise is almost negligible if one uses a sufficient number of bits. Let's take a look at the quantization error more carefully."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Run code in this cell to see the difference between the original and quantized signals (quantization error)\n",
      "num_of_bits = 1\n",
      "quantized_song = quantizer(num_of_bits,song)\n",
      "plt.plot(time[0:441], song[0:441] - quantized_song[0:441])\n",
      "plt.title('Quantization Error')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## <font color=blue>Q2. Plot the mean squared error between the original and quantized signal as a function of number of bits used for a quantizer. Consider $1 \\leq \\ell \\leq 10$. Observe how fast the MSE drops as you increase $\\ell$. Is it linearly decreasing? Or is it exponentially decreasing? First plot the MSE, then change the y-axis to a log-scale.</font>\n",
      "\n",
      "Note: The MSE is the <a href=\"http://mathworld.wolfram.com/L2-Norm.html\">$l^2$-norm</a>  of the quantization noise divided by the number of noise samples."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Q2. Your Beautiful Code Here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "___"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "You should see that the MSE does indeed drop exponentially! This result was easily confirmed via simulation, so let's do some calculations to obtain the same results via analysis."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Sampling & Quantization: Analysis"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "In order to analyze the effect of quantization noise, we need to come up with a good model for the quantization noise. Although everything we did was deterministic, what we saw above was really just one specific realization of quantization. For each sample, the original value was mapped to the nearest quantization point. The distance between the chosen quantization point and the original value became the quantization noise for the sample. But how bad is the error on the whole?\n",
      "\n",
      "Let's just start by modelling the noise as a <b>uniform random variable</b>. If the original signal is assumed to take each value chosen at uniformly random, the model will be precise. However, is this model also valid for structured signals such as a combination of sinusoidal waves? Let's take a look at a 'noise histogram' to find out. "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "num_of_bits = 8\n",
      "# time, song = sampler(sampling_rate)\n",
      "quantized_song = quantizer(num_of_bits, song)\n",
      "matplotlib.pyplot.hist( (song - quantized_song ) , 30 );\n",
      "plt.title('Noise Histogram')\n",
      "plt.xlabel('Quantization Error')\n",
      "plt.ylabel('Occurances')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "We see that the quantization error is not exactly uniform, but extremely close. There is one value which occurs significantly more frequently than the rest, but that is an artifact of the structure of a sinusoid (they like to hang around -1 and 1 for a while). If we consider general signals, the model of quantization noise as uniform is even more accurate, although it is not too bad in this case either."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## <font color=blue>Q3. Given that the error between a quantized signal and the original is modeled as a uniform random variable, justify that the MSE will drop exponentially. Find an equation for $\\mathbb{E}[\\text{MSE}]$ given an arbitrary number of bits $\\ell$. On a log scale, plot the expected MSE given the uniform model along with the achieved MSE for the signal above for $1 \\leq \\ell \\leq 10$. Do they decay similarly?</font>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Q3. Your Solution Here"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Q3. Plotting Code Here"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "_____________"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## Compression: Twitter Revolution\n",
      "Before attempting this section, brush up on (or learn for the first time) <a href=\"http://www.arbitrarylabs.com/huffman.pdf\">Huffman coding</a>.\n",
      "\n",
      "\n",
      "Your friend Ben Bitdiddle just returned from Tunisia and wants to start a revolution at UC Berkeley. He knows Twitter can be an important tool for revolution, but it has a major problem: 140 characters just isn't enough. For example, Ben wants to send the tweet:\n",
      "\n",
      "<center><img src=\"http://arbitrarylabs.com/tweet1.png\" alt=\"Tweet1\"></center>\n",
      "<center><img src=\"http://arbitrarylabs.com/tweet2.png\" alt=\"Tweet2\"></center>\n",
      "\n",
      "\n",
      "The tweet exceeded 140 characters and he had to send it in **2 separate tweets**, which dramatically reduces the impact of his revolutionary message. If people read the first tweet, they won't know where the protest is located; if they read the second, they may get to the protest, but they won't know why they are protesting!\n",
      "\n",
      "Ben has devised a new scheme to _compress_ his tweets so he can fit his longer messages into 140 characters. There are only 32 characters that he uses in his tweets (26 letters + 6 punctuation), but not all of them occur equally often, so he will use a Huffman code as follows:\n",
      "1. He will encode his tweet as a binary string using a Huffman code based on the letter frequencies determined by the hash table `freq_dict` below.\n",
      "2. He will convert this bit-string back into letters according to the `bits2letters` mapping defined below. If the bitstring created by the Huffman code does not have a length which is a multiple of 5, he will append the Huffman code for the character `SPACE` to the bitstring until it _does_ have length which is a multiple of 5."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "english_freq_dict = {'!': 0.0008, \"'\": 0.0004, ' ': 0.1033, ',': 0.0011,\\\n",
      "             '.': 0.0011, '?': 0.0006, 'a': 0.069, 'c': 0.027000000000000003,\\\n",
      "             'b': 0.013999999999999999, 'e': 0.1, 'd': 0.039, 'g': 0.021, 'f': 0.022000000000000002,\\\n",
      "             'i': 0.06, 'h': 0.048, 'k': 0.008, 'j': 0.0014000000000000002, 'm': 0.025,\\\n",
      "             'l': 0.043, 'o': 0.065, 'n': 0.06, 'q': 0.0017000000000000001, 'p': 0.02,\\\n",
      "             's': 0.055999999999999994, 'r': 0.052000000000000005, 'u': 0.027000000000000003,\\\n",
      "             't': 0.083, 'w': 0.017, 'v': 0.0108, 'y': 0.018000000000000002, 'x': 0.0036, 'z': 0.0012}"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "letters2bits = {'!': '11101', \"'\": '11111', ' ': '11010', ',': '11100', \\\n",
      "            '.': '11011', '?': '11110', 'a': '00000', 'c': '00010', 'b': '00001', 'e': '00100', \\\n",
      "            'd': '00011', 'g': '00110', 'f': '00101', 'i': '01000', 'h': '00111', 'k': '01010',\\\n",
      "            'j': '01001', 'm': '01100', 'l': '01011', 'o': '01110', 'n': '01101', 'q': '10000', \\\n",
      "            'p': '01111', 's': '10010', 'r': '10001', 'u': '10100', 't': '10011', 'w': '10110', 'v': '10101',\\\n",
      "            'y': '11000', 'x': '10111', 'z': '11001'}\n",
      "\n",
      "def reverse_dict(original_dict):\n",
      "    # create a new dict with the keys of original_dict as values and the values of original_dict as keys\n",
      "    new_dict = {}\n",
      "    for key in original_dict:\n",
      "        new_dict[original_dict[key]] = key\n",
      "    return new_dict\n",
      "\n",
      "bits2letters = reverse_dict(letters2bits)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      ">Characters and their frequencies in the English language:\n",
      "\n",
      "| Character | Frequency |\n",
      "|---------- |-------------------|\n",
      "| SPACE     | 0.1033\n",
      "|  e        | 0.1\n",
      "|  t        | 0.083\n",
      "|  a        | 0.069\n",
      "|  o        | 0.065\n",
      "|  i        | 0.06\n",
      "|  n        | 0.06\n",
      "|  s        | 0.056\n",
      "|  r        | 0.052\n",
      "|  h        | 0.048\n",
      "|  l        | 0.043\n",
      "|  d        | 0.039\n",
      "|  c        | 0.027\n",
      "|  u        | 0.027\n",
      "|  m        | 0.025\n",
      "|  f        | 0.022\n",
      "|  g        | 0.021\n",
      "|  p        | 0.02\n",
      "|  y        | 0.018\n",
      "|  w        | 0.017\n",
      "|  b        | 0.014\n",
      "|  v        | 0.0108\n",
      "|  k        | 0.008\n",
      "|  x        | 0.0036\n",
      "|  q        | 0.0017\n",
      "|  j        | 0.0014\n",
      "|  z        | 0.0012\n",
      "|  ,        | 0.0011\n",
      "|  .        | 0.0011\n",
      "|  !        | 0.0008\n",
      "|  ?        | 0.0006\n",
      "|  '        | 0.0004"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## <font color = blue>Q4. Implement Huffman. In this question we will develop Ben's strategy for Huffman Coded Tweets.</font>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### <font color=blue>a. Implement a method that, given a list of frequencies, will output the corresponding mapping of input symbol to Huffman codewords</font>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from heapq import heappush, heappop, heapify\n",
      "from collections import defaultdict\n",
      " \n",
      "def HuffEncode(freq_dict):\n",
      "    \"\"\"Return a dictionary (letters2huff) which maps keys from the input dictionary freq_dict\n",
      "       to bitstrings using a Huffman code based on the frequencies of each key\"\"\"\n",
      "\n",
      "    # Your Beautiful Code Here #\n",
      "\n",
      "    return letters2huff"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### <font color=blue>b. Using this method, generate the mapping from our alphabet to their corresponding Huffman codewords. Print this mapping in a readable format.</font>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "letters2huff = HuffEncode(english_freq_dict)\n",
      "huff2letters = reverse_dict(letters2huff)\n",
      "# print dictionary in readable format"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### <font color=blue>c. Write a method to encode a string using this Huffman mapping into a binary string and then use the `bits2letters` mapping above to turn this binary string back into english characters. These characters will be different than the original message, and there should be fewer of them. Encode the string containing the desired tweet (provided below as `original_string`).</font>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def encode_string(string, letters2huff):\n",
      "    \"\"\"Return a bitstring encoded according to the Huffman code defined in the dictionary letters2huff.\n",
      "       If your resulting bitstring does not have a length which is a multiple of five, add the binary for\n",
      "       SPACE characters until it is.\"\"\"\n",
      "    \n",
      "    # Your Beautiful Code Here\n",
      "    \n",
      "    return encoded_string"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "original_string = 'grades are a fundamentally oppressive tool used by academic institutions to equate the value of a human being with a letter and a number! protest coryhall tonight'\n",
      "encoded_string = encode_string(original_string)\n",
      "\n",
      "print \"Original String: \" , original_string\n",
      "print \"Length of Original String: \" , len(original_string)\n",
      "print \"Encoded String: \" , encoded_string\n",
      "print \"Length of Encoded String: \" , len(encoded_string)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Can you successfully post your message now?"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### <font color=blue>d. Write a function to decode a Huffman coded tweet back into the original english tweet that generated it. The result should be that</font>\n",
      "\n",
      "\\>\\>\\> `decode_string(encode_string('hello world', letters2huff), huff2letters)`\n",
      "\n",
      "`\"hello world\"`\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def decode_string(coded_string, letters2huff):\n",
      "    \"\"\"Translate from a Huffman coded string to a regular string\"\"\"\n",
      "    \n",
      "    # Your Code Here #\n",
      "    \n",
      "    return decoded_string"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print decode_string(encode_string('hello world', letters2huff), huff2letters)\n",
      "print decode_string(encode_string(original_string, letters2huff), huff2letters)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "After implementing the coding system described above, Ben was able to tweet the following (138 characters), while still conveying his full, original message:\n",
      "\n",
      "<center><img src=\"http://arbitrarylabs.com/tweet3.png\" alt=\"Tweet3\"></center>\n",
      "\n",
      "Wow! That's the kind of tweet that will really get me excited to revolt!\n"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "## <font color=blue>Q4. Are Huffman codes unique? Should you be worried that the tweet you generate may not precisely match the tweet Ben generated above?</font>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "A4. Your Solution Here"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "___"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Congratulations, you can now quantize children's songs and Huffman code tweets. You're really moving up in the world!"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}