RTT.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Reversible Truth Tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "input_headers = ['x', 'y', 'z']\n",
    "output_headers = ['output1', 'output2']\n",
    "input = np.array([[0,0,0], [0,0,1], [0,1,0], [0,1,1], [1,0,0], [1,0,1], [1,1,0], [1,1,1],])\n",
    "output = np.array([[0,0], [0,0], [0,0], [0,0], [0,0], [0,0], [0,0], [0,0]])\n",
    "\n",
    "full_add_input_headers = ['cin', 'x', 'y']\n",
    "full_add_output_headers = ['cout', 'sum']\n",
    "full_add_input = np.array([[0,0,0], [0,0,1], [0,1,0], [0,1,1], [1,0,0], [1,0,1], [1,1,0], [1,1,1],])\n",
    "full_add_output = np.array([[0,0], [0,1], [0,1], [1,0], [0,1], [1,0], [1,0], [1,1]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "input_headers = ['x', 'y']\n",
    "output_headers = ['output1', 'output2', 'output3']\n",
    "input = np.array([[0,0], [0,1], [1,0], [1,1]])\n",
    "output = np.array([[0,0,0], [0,0,0], [0,0,0], [0,0,0], [0,0,0], [0,0,0], [0,0,0], [0,0,0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def printTruthTable(input, output, input_headers, output_headers):\n",
    "#     if len(input) != len(output):\n",
    "#         print(\"input does not match output length\")\n",
    "#         return \n",
    "    row_num = 0\n",
    "    header = \"| \"\n",
    "\n",
    "    for col in range(input.shape[1]):\n",
    "        header = header + input_headers[col] + \" | \"\n",
    "    header = header + \"| \"\n",
    "    \n",
    "    for col in range(output.shape[1]):\n",
    "        header = header + output_headers[col] + \" | \"\n",
    "    \n",
    "    div = \"\"\n",
    "    for i in header:\n",
    "        div += \"-\"\n",
    "        \n",
    "    print(header)\n",
    "    print(div)\n",
    "    \n",
    "    for row in input:\n",
    "        line = \"| \"\n",
    "        for i, index in enumerate(row):\n",
    "            space = \"\"\n",
    "            for item in range(len(input_headers[i])):\n",
    "                space += \" \"\n",
    "            line = line + str(index) + space + \"| \"\n",
    "        line = line + \"| \"\n",
    "        for i, index in enumerate(output[row_num]):\n",
    "            space = \"\"\n",
    "            for item in range(len(output_headers[i])):\n",
    "                space += \" \"\n",
    "            line = line + str(index) + space + \"| \"\n",
    "        print(line)\n",
    "        row_num += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| x | y | z | | output1 | output2 | \n",
      "------------------------------------\n",
      "| 0 | 0 | 0 | | 0       | 0       | \n",
      "| 0 | 0 | 1 | | 0       | 0       | \n",
      "| 0 | 1 | 0 | | 0       | 0       | \n",
      "| 0 | 1 | 1 | | 0       | 0       | \n",
      "| 1 | 0 | 0 | | 0       | 0       | \n",
      "| 1 | 0 | 1 | | 0       | 0       | \n",
      "| 1 | 1 | 0 | | 0       | 0       | \n",
      "| 1 | 1 | 1 | | 0       | 0       | \n"
     ]
    }
   ],
   "source": [
    "printTruthTable(input, output, input_headers, output_headers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from pandas import *\n",
    "\n",
    "def duplicate(decodeArray):\n",
    "    seen = set()\n",
    "    newList = []\n",
    "    for item in decodeArray:\n",
    "        t = tuple(item)\n",
    "        if t not in seen: \n",
    "            newList.append(item)\n",
    "            seen.add(t)\n",
    "    return newList\n",
    "\n",
    "def isReversible(input, output):\n",
    "    if input.shape == output.shape:\n",
    "        # check if one to one\n",
    "        seen = set()\n",
    "        unique_rows = []\n",
    "        for item in output:\n",
    "            t = tuple(item)\n",
    "            if t not in seen: \n",
    "                unique_rows.append(item)\n",
    "                seen.add(t)\n",
    "        unique_rows = np.array(unique_rows)\n",
    "        return unique_rows.shape == output.shape\n",
    "    else:\n",
    "        return False\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isReversible(input, output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def reverse(input, output, input_headers, output_headers, dict={}):\n",
    "    max_key = max(dict, key= lambda x: len(set(dict[x])))\n",
    "    num_garbage = len(dict[max_key])\n",
    "    print(\"Number of garbage bits needed: \" + str(len(\"{0:b}\".format(num_garbage))))\n",
    "    num_antica = (num_garbage + output.shape[1]) - input.shape[1]\n",
    "    print(\"Number of antica bits needed: \" + str(len(\"{0:b}\".format(num_antica))))\n",
    "\n",
    "    # makes onto\n",
    "    new_input = np.hstack((input, np.zeros((input.shape[0], len(\"{0:b}\".format(num_antica))), dtype=input.dtype)))\n",
    "    new_input_headers = input_headers\n",
    "    for i in range(len(\"{0:b}\".format(num_antica))):\n",
    "        new_input_headers.append(\"a\"+ str(i))\n",
    "    new_output = np.hstack((output, np.zeros((output.shape[0], len(\"{0:b}\".format(num_garbage))), dtype=input.dtype)))\n",
    "    new_output_headers = output_headers\n",
    "    for i in range(len(\"{0:b}\".format(num_garbage))):\n",
    "        new_output_headers.append(\"g\"+ str(i))\n",
    "        \n",
    "    #make one to one\n",
    "    new_input, new_output = synthesize(new_input, new_output, len(\"{0:b}\".format(num_antica)), len(\"{0:b}\".format(num_garbage)),dict)\n",
    "    return (new_input, new_output, new_input_headers, new_output_headers)\n",
    "\n",
    "def synthesize(input, output, num_antica, num_garbage, duplicates={}):\n",
    "    buffer = output.shape[1] - num_garbage\n",
    "    get_bin = lambda x, n: format(x, 'b').zfill(n)\n",
    "    \n",
    "    for key in duplicates:\n",
    "        number = 1\n",
    "        for item in duplicates[key]:\n",
    "            garbage = get_bin(number, num_garbage)\n",
    "            for col in range(num_garbage):\n",
    "                output[item][col+buffer] = int(garbage[col])\n",
    "            number = number + 1\n",
    "                        \n",
    "    return (input, output)\n",
    "\n",
    "def makeReversible(input, output, input_headers, output_headers): \n",
    "    seen = set()\n",
    "    duplicates = {}\n",
    "    index = 0 \n",
    "    for row in output:\n",
    "        t = tuple(row)\n",
    "        if t in seen:\n",
    "            if t in duplicates:\n",
    "                duplicates[t].append(index)\n",
    "            else:\n",
    "                duplicates[t] = [index]\n",
    "        seen.add(t)\n",
    "        index += 1    \n",
    "    \n",
    "    if isReversible(input, output):\n",
    "        print(\"Truth Table already reversible\")\n",
    "        return (input, output, input_headers, output_headers)\n",
    "    else:\n",
    "        return reverse(input, output, input_headers, output_headers, duplicates)\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of garbage bits needed: 3\n",
      "Number of antica bits needed: 3\n",
      "{(0, 0): [1, 2, 3, 4, 5, 6, 7]}\n"
     ]
    }
   ],
   "source": [
    "new_input, new_output, new_input_headers, new_output_headers = makeReversible(input, output, input_headers, output_headers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| x | y | z | a0 | a1 | a2 | | output1 | output2 | g0 | g1 | g2 | \n",
      "------------------------------------------------------------------\n",
      "| 0 | 0 | 0 | 0  | 0  | 0  | | 0       | 0       | 0  | 0  | 0  | \n",
      "| 0 | 0 | 1 | 0  | 0  | 0  | | 0       | 0       | 0  | 0  | 1  | \n",
      "| 0 | 1 | 0 | 0  | 0  | 0  | | 0       | 0       | 0  | 1  | 0  | \n",
      "| 0 | 1 | 1 | 0  | 0  | 0  | | 0       | 0       | 0  | 1  | 1  | \n",
      "| 1 | 0 | 0 | 0  | 0  | 0  | | 0       | 0       | 1  | 0  | 0  | \n",
      "| 1 | 0 | 1 | 0  | 0  | 0  | | 0       | 0       | 1  | 0  | 1  | \n",
      "| 1 | 1 | 0 | 0  | 0  | 0  | | 0       | 0       | 1  | 1  | 0  | \n",
      "| 1 | 1 | 1 | 0  | 0  | 0  | | 0       | 0       | 1  | 1  | 1  | \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_input = np.array(new_input)\n",
    "new_output = np.array(new_output)\n",
    "printTruthTable(new_input, new_output, new_input_headers, new_output_headers)\n",
    "isReversible(new_input, new_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| cin | x | y | | cout | sum | \n",
      "-------------------------------\n",
      "| 0   | 0 | 0 | | 0    | 0   | \n",
      "| 0   | 0 | 1 | | 0    | 1   | \n",
      "| 0   | 1 | 0 | | 0    | 1   | \n",
      "| 0   | 1 | 1 | | 1    | 0   | \n",
      "| 1   | 0 | 0 | | 0    | 1   | \n",
      "| 1   | 0 | 1 | | 1    | 0   | \n",
      "| 1   | 1 | 0 | | 1    | 0   | \n",
      "| 1   | 1 | 1 | | 1    | 1   | \n"
     ]
    }
   ],
   "source": [
    "# Full Adder\n",
    "printTruthTable(full_add_input, full_add_output, full_add_input_headers, full_add_output_headers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of garbage bits needed: 2\n",
      "Number of antica bits needed: 1\n",
      "{(0, 1): [2, 4], (1, 0): [5, 6]}\n",
      "| cin | x | y | a0 | | cout | sum | g0 | g1 | \n",
      "----------------------------------------------\n",
      "| 0   | 0 | 0 | 0  | | 0    | 0   | 0  | 0  | \n",
      "| 0   | 0 | 1 | 0  | | 0    | 1   | 0  | 0  | \n",
      "| 0   | 1 | 0 | 0  | | 0    | 1   | 0  | 1  | \n",
      "| 0   | 1 | 1 | 0  | | 1    | 0   | 0  | 0  | \n",
      "| 1   | 0 | 0 | 0  | | 0    | 1   | 1  | 0  | \n",
      "| 1   | 0 | 1 | 0  | | 1    | 0   | 0  | 1  | \n",
      "| 1   | 1 | 0 | 0  | | 1    | 0   | 1  | 0  | \n",
      "| 1   | 1 | 1 | 0  | | 1    | 1   | 0  | 0  | \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_input, new_output, new_input_headers, new_output_headers = makeReversible(full_add_input, full_add_output, full_add_input_headers, full_add_output_headers)\n",
    "new_input = np.array(new_input)\n",
    "new_output = np.array(new_output)\n",
    "printTruthTable(new_input, new_output, new_input_headers, new_output_headers)\n",
    "isReversible(new_input, new_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "get_bin = lambda x, n: format(x, 'b').zfill(n)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "101"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(get_bin(5, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "Number of garbage bits needed: 2\n",
      "Number of antica bits needed: 2\n",
      "3\n",
      "Number of garbage bits needed: 3\n",
      "Number of antica bits needed: 3\n",
      "4\n",
      "Number of garbage bits needed: 4\n",
      "Number of antica bits needed: 4\n",
      "5\n",
      "Number of garbage bits needed: 5\n",
      "Number of antica bits needed: 5\n",
      "6\n",
      "Number of garbage bits needed: 6\n",
      "Number of antica bits needed: 6\n",
      "7\n",
      "Number of garbage bits needed: 7\n",
      "Number of antica bits needed: 7\n",
      "8\n",
      "Number of garbage bits needed: 8\n",
      "Number of antica bits needed: 8\n",
      "9\n",
      "Number of garbage bits needed: 9\n",
      "Number of antica bits needed: 9\n",
      "10\n",
      "Number of garbage bits needed: 10\n",
      "Number of antica bits needed: 10\n",
      "11\n",
      "Number of garbage bits needed: 11\n",
      "Number of antica bits needed: 11\n",
      "12\n",
      "Number of garbage bits needed: 12\n",
      "Number of antica bits needed: 12\n"
     ]
    }
   ],
   "source": [
    "import numpy as np \n",
    "import time\n",
    "\n",
    "times = []\n",
    "n_vals = [2, 3, 4, 5,6,7,8,9,10,11,12]\n",
    "for n in n_vals:\n",
    "    print(n)\n",
    "    input = []\n",
    "    output = []\n",
    "    input_headers = []\n",
    "    output_headers = []\n",
    "    for i in range(2**n):\n",
    "        input.append(list(map(int, get_bin(i, n))))\n",
    "\n",
    "    for i in range(2**n):\n",
    "        output.append(list(map(int, get_bin(0, n))))\n",
    "\n",
    "    for i in range(n):\n",
    "        input_headers.append('x')\n",
    "        output_headers.append('y')\n",
    "\n",
    "    input = np.array(input)\n",
    "    output = np.array(output)\n",
    "    \n",
    "    start = time.time()\n",
    "    new_input, new_output, new_input_headers, new_output_headers = makeReversible(input, output, input_headers, output_headers)\n",
    "    end = time.time()\n",
    "    times.append(end - start)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0032100677490234375, 0.0003631114959716797, 0.00040793418884277344, 0.0009419918060302734, 0.00191497802734375, 0.0037310123443603516, 0.007073163986206055, 0.020654916763305664, 0.023669004440307617, 0.04853081703186035, 0.10210704803466797]\n"
     ]
    }
   ],
   "source": [
    "print(times)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAicAAAGHCAYAAABrpPKuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x117398780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.interpolate import spline\n",
    "\n",
    "x_val = ['']\n",
    "x = np.array(n_vals)\n",
    "plt.xticks(x, n_vals)\n",
    "plt.plot(x, times, 'b-o')\n",
    "xnew = np.linspace(x.min(),x.max(),300) \n",
    "\n",
    "power_smooth = spline(x,times,xnew)\n",
    "\n",
    "plt.plot(xnew,power_smooth, 'r--')\n",
    "plt.ylabel('Time (in seconds)')\n",
    "plt.xlabel('n (number of bits)')\n",
    "plt.title('n vs Time')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}