project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# EC444 Synthesis and optimization of digital circuits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Ram Janam Yadav  181EC136\n",
    "\n",
    "2. Harshith         181EC116"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a SoP form of Boolean expression, write a program ( in python/C/Java/TclTk/Pearl) to\n",
    "1. Find the cofactors of the function with respect to any given variable or a set of variables (a, ab ab’ etc) and display the results.\n",
    "2. For a given variable ordering, find and display the ROBDD of the function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Part-1 finding the cofactors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Import All required Libraries\"\"\"\n",
    "import copy\n",
    "\n",
    "def variable_seperation(cube):\n",
    "    \"\"\"function is used for the variable separation from given sop form of boolean expression\"\"\"\n",
    "    var = []\n",
    "    for c in cube: \n",
    "        b = []\n",
    "        a = list(c)\n",
    "        a.append(\" \") \n",
    "        for i in range(len(a)-1):\n",
    "            if a[i+1] == \"'\":\n",
    "                l = \"\".join(a[i]+a[i+1])\n",
    "            elif a[i] == \"'\" or a[i] == \" \":\n",
    "                continue\n",
    "            else:\n",
    "                l = a[i]\n",
    "            b.append(l)\n",
    "            for z in range(len(b)):\n",
    "                for y in range(len(b)):\n",
    "                    x = y+z+1\n",
    "                    if x<len(b) and b[z] == b[x]:\n",
    "                        b.pop(x)\n",
    "                        x = x-1\n",
    "        var.append(b)\n",
    "    return var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Put function here: ab+cd\n",
      "put set of variable with respect to which you want the cofactor for ex a,ab,ab' : ac'\n",
      "['ab', 'cd']\n"
     ]
    }
   ],
   "source": [
    "fn = input(\"Put function here: \" )\n",
    "cf_fn = input(\"put set of variable with respect to which you want the cofactor for ex a,ab,ab' : \")\n",
    "\n",
    "cubes = fn.split('+')\n",
    "print(cubes)\n",
    "fn_vars = variable_seperation(cubes)# variables in given sop expression after variable separation\n",
    "cf_vars = variable_seperation(cf_fn.split(\" \"))#split the cofactor variables\n",
    "co_py = copy.deepcopy(fn_vars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['a', 'b'], ['c', 'd']]\n"
     ]
    }
   ],
   "source": [
    "print(fn_vars)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['a', \"c'\"]]\n"
     ]
    }
   ],
   "source": [
    "print(cf_vars)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['a', 'b'], ['c', 'd']]\n"
     ]
    }
   ],
   "source": [
    "print(co_py)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cofactor with respect to given variable or set of variables is b\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(cf_vars[0])):\n",
    "    var = cf_vars[0][i]\n",
    "    if co_py[0][0] == '1':\n",
    "            break\n",
    "    a = 0\n",
    "    b = [0]* len(co_py)\n",
    "    for j in range(len(co_py)):\n",
    "        t = 0\n",
    "        for h in range(len(co_py[j-a])):       \n",
    "            if co_py and co_py[j-a] and var[0] == co_py[j-a][h-b[j-a]][0]:\n",
    "                if len(var) == len(co_py[j-a][h-b[j-a]]):\n",
    "                    co_py[j-a].pop(h-b[j-a])\n",
    "                    b[j-a] = b[j-a]+1\n",
    "                    if not co_py[j-a]:\n",
    "                        co_py = [['1']]\n",
    "                        break\n",
    "                else:\n",
    "                    co_py.pop(j-a)\n",
    "                    t = 1\n",
    "                    a = a + 1\n",
    "                if t == 1:\n",
    "                    break\n",
    "        if not co_py:\n",
    "            co_py = [['0']]\n",
    "        elif co_py[0][0] == '1':\n",
    "            break \n",
    "\n",
    "\n",
    "i = []\n",
    "for j in co_py:\n",
    "    i.append(\"\".join(j))\n",
    "    \n",
    "output = \"+\".join(i)\n",
    "print('cofactor with respect to given variable or set of variables is',output)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Part 2 For a given variable ordering, find and display the ROBDD of the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter function here: ab+cd\n",
      "Enter variable order here: a b c d\n",
      "depth_first_traversals_inorder\n",
      "0\n",
      "c\n",
      "0\n",
      "d\n",
      "1\n",
      "a\n",
      "0\n",
      "c\n",
      "0\n",
      "d\n",
      "1\n",
      "b\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "class node:\n",
    "    \"\"\"Class to create the nodes of graph\"\"\"\n",
    "    def __init__(self, val = None):\n",
    "        \"\"\"Initialization of the Node of graph which have one high pointer->1 and other low pointer->0\"\"\"\n",
    "        self.var = val\n",
    "        self.high = None\n",
    "        self.low = None\n",
    "        \n",
    "node_low = node(\"0\")\n",
    "node_high = node(\"1\")\n",
    "\n",
    "def get_put_UT(key, node_):\n",
    "    \"\"\"Used to create the Unique Table for The Nodes in graph\"\"\"\n",
    "    if key in unique_table.keys():\n",
    "        #print(1)\n",
    "        return unique_table[key]\n",
    "    else:\n",
    "        unique_table[key] = node_\n",
    "        return node_\n",
    "\n",
    "def var_sep(cube):\n",
    "    \"\"\"function is used for the variable separation from given sop form of boolean expression\"\"\"\n",
    "    d = []\n",
    "    for c in cube: \n",
    "        b = []\n",
    "        a = list(c)\n",
    "        a.append(\" \") \n",
    "        for i in range(len(a)-1):\n",
    "            if a[i+1] == \"'\":\n",
    "                l = \"\".join(a[i]+a[i+1])\n",
    "            elif a[i] == \"'\" or a[i] == \" \":\n",
    "                continue\n",
    "            else:\n",
    "                l = a[i]\n",
    "            b.append(l)\n",
    "            for z in range(len(b)):\n",
    "                for y in range(len(b)):\n",
    "                    x = y+z+1\n",
    "                    if x<len(b) and b[z] == b[x]:\n",
    "                        b.pop(x)\n",
    "                        x = x-1\n",
    "        d.append(b)\n",
    "    return d\n",
    "\n",
    "def cofactor(fn,var_):\n",
    "    \"\"\"Function is Used to calculate the Cofactor of the fn w.r.t given variable\"\"\"\n",
    "    cubes = fn.split('+')\n",
    "    fn_vars = var_sep(cubes)\n",
    "    cf_vars = var_sep(var_.split(\" \"))\n",
    "    co_py = copy.deepcopy(fn_vars)\n",
    "    for i in range(len(cf_vars[0])):\n",
    "        var = cf_vars[0][i]\n",
    "        if co_py[0][0] == '1':\n",
    "            break\n",
    "        a = 0\n",
    "        b = [0]* len(co_py)\n",
    "        for j in range(len(co_py)):\n",
    "            t = 0\n",
    "            for h in range(len(co_py[j-a])):       \n",
    "                if co_py and co_py[j-a] and var[0] == co_py[j-a][h-b[j-a]][0]:\n",
    "                    if len(var) == len(co_py[j-a][h-b[j-a]]):\n",
    "                        co_py[j-a].pop(h-b[j-a])\n",
    "                        b[j-a] = b[j-a]+1\n",
    "                        \n",
    "                        if not co_py[j-a]:\n",
    "                            co_py = [['1']]\n",
    "                            break\n",
    "                    else:\n",
    "                        co_py.pop(j-a)\n",
    "                        t = 1\n",
    "                        a = a + 1\n",
    "\n",
    "                    if t == 1:\n",
    "                        break\n",
    "            if not co_py:\n",
    "                co_py = [['0']]\n",
    "            elif co_py[0][0] == '1':\n",
    "                break \n",
    "    i = []\n",
    "    for j in co_py:\n",
    "        i.append(\"\".join(j))\n",
    "    output = \"+\".join(i)\n",
    "    return output\n",
    "\n",
    "def depth_first_traversals_inorder(top): \n",
    "    \"\"\"Function is used for DFS traversal of the resultant graph\"\"\"\n",
    "    if top: \n",
    "        depth_first_traversals_inorder(top.low) \n",
    "        print(top.var)\n",
    "        depth_first_traversals_inorder(top.high)\n",
    "\n",
    "def ite(function, variable_order, i):\n",
    "    \"\"\"Iterative Algorithm implementation for ROBDD construction\"\"\"\n",
    "    var = variable_order[i]\n",
    "    cofactor_high = cofactor(function, var)\n",
    "    var_bar = var+\"'\"\n",
    "    cofactor_low = cofactor(function, var_bar)\n",
    "    key = var + cofactor_high + cofactor_low\n",
    "    node_ = node(var)\n",
    "    if cofactor_high==\"0\":\n",
    "        node_.high = node_low\n",
    "    if cofactor_high==\"1\":\n",
    "        node_.high = node_high\n",
    "    if cofactor_low==\"0\":\n",
    "        node_.low = node_low\n",
    "    if cofactor_low == \"1\":\n",
    "        node_.low = node_high\n",
    "        \n",
    "    if node_.high == None:\n",
    "        node_.high = ite(cofactor_high, variable_order, i+1)\n",
    "    if node_.low == None:\n",
    "        node_.low = ite(cofactor_low, variable_order, i+1)\n",
    "    \n",
    "    node_ = get_put_UT(key, node_)\n",
    "    if node_.high == node_.low:\n",
    "        return node_.high\n",
    "    return node_\n",
    "\n",
    "unique_table = {}\n",
    "\n",
    "fn = input('Enter function here: ')\n",
    "var_order = list(input('Enter variable order here: '))\n",
    "\n",
    "robdd = ite(fn, var_order, 0)\n",
    "\n",
    "print(\"depth_first_traversals_inorder\")\n",
    "depth_first_traversals_inorder(robdd)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter function here: ab+cd+efg+ghi\n",
      "Enter variable order here: a b c d e f g h i\n"
     ]
    }
   ],
   "source": [
    "def ite1(G,function, variable_order, i):\n",
    "    \"\"\"Iterative Algorithm implementation for ROBDD construction\"\"\"\n",
    "    var = variable_order[i]\n",
    "    cofactor_high = cofactor(function, var)\n",
    "    var_bar = var+\"'\"\n",
    "    cofactor_low = cofactor(function, var_bar)\n",
    "    key = var + cofactor_high + cofactor_low\n",
    "    node_ = node(var)\n",
    "    if cofactor_high==\"0\":\n",
    "        node_.high = node_low\n",
    "        G.add_edge(node_.var,node_.high.var)\n",
    "    if cofactor_high==\"1\":\n",
    "        node_.high = node_high\n",
    "        G.add_edge(node_.var,node_.high.var)\n",
    "    if cofactor_low==\"0\":\n",
    "        node_.low = node_low\n",
    "        G.add_edge(node_.var,node_.low.var)\n",
    "    if cofactor_low == \"1\":\n",
    "        node_.low = node_high\n",
    "        G.add_edge(node_.var,node_.low.var)\n",
    "        \n",
    "    if node_.high == None:\n",
    "        node_.high = ite1(G, cofactor_high, variable_order, i+1)\n",
    "        if(node_.high!=None):\n",
    "            G.add_edge(node_.var, node_.high.var)\n",
    "    if node_.low == None:\n",
    "        node_.low = ite1(G, cofactor_low, variable_order, i+1)\n",
    "        if(node_.low!=None):\n",
    "            G.add_edge(node_.var, node_.low.var)\n",
    "    \n",
    "    node_ = get_put_UT(key, node_)\n",
    "    if node_.high == node_.low:\n",
    "        return node_.high\n",
    "    return node_\n",
    "\n",
    "\n",
    "import networkx as nx\n",
    "G = nx.Graph()\n",
    "unique_table = {}\n",
    "\n",
    "fn = input('Enter function here: ')\n",
    "var_order = list(input('Enter variable order here: '))\n",
    "\n",
    "robdd = ite1(G, fn, var_order, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from networkx.drawing.nx_pydot import graphviz_layout\n",
    "pos = graphviz_layout(G, prog=\"dot\")\n",
    "nx.draw(G,with_labels=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All connected edge in the graph [('b', '1'), ('b', 'c'), ('b', ' '), ('b', 'a'), ('1', 'd'), ('1', 'g'), ('1', 'i'), ('d', 'e'), ('d', ' '), ('d', 'c'), ('g', '0'), ('g', ' '), ('g', 'f'), ('g', 'h'), ('g', 'e'), ('0', 'h'), ('0', 'i'), (' ', 'i'), (' ', 'h'), (' ', 'f'), (' ', 'e'), (' ', 'c'), ('f', 'e'), ('h', 'i'), ('e', 'c'), ('c', 'a')]\n"
     ]
    }
   ],
   "source": [
    "print(\"All connected edge in the graph\",G.edges())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thank You!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}