SCOAP  Controllability and Observability.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "thick-budget",
   "metadata": {},
   "source": [
    "# DVTT Assignment 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thermal-witch",
   "metadata": {},
   "source": [
    "# SCOAP  Controllability and Observability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "valid-rapid",
   "metadata": {},
   "outputs": [],
   "source": [
    "#import every lines from txt file and store it in list m\n",
    "netlist = []\n",
    "with open('mux.txt') as f:\n",
    "    netlist = f.readlines()\n",
    "#print(netlist)\n",
    "lines = len(netlist)  #lines --> numbers of lines in netlist.\n",
    "\n",
    "m=[]   #empty list to store each line as list.\n",
    "k=[]   #temporary empty list.\n",
    "for i in range(lines):\n",
    "    k = netlist[i].split()\n",
    "    m.append(k)\n",
    "m_copy = m.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "comic-williams",
   "metadata": {},
   "outputs": [],
   "source": [
    "#copy all fanout lines to fanout_list\n",
    "fanout_list= [] #[FANOUT, input , outputs......]\n",
    "for i in range(len(m)):\n",
    "    if (m[i][0] == 'FANOUT'):\n",
    "        fanout_list.append(m[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "unique-tower",
   "metadata": {},
   "outputs": [],
   "source": [
    "#copy all gates list to gates_list\n",
    "#copy output input fanout lines to out_in_fanout_list\n",
    "out_in_fanout_list= []  #list of input,output,fanout\n",
    "gates_list= [] #list of all gates\n",
    "input_list = []\n",
    "for i in range(len(m)):\n",
    "    if (m[i][0] == 'FANOUT') or (m[i][0] == 'OUTPUT') or (m[i][0] == 'INPUT'):\n",
    "        out_in_fanout_list.append(m[i])\n",
    "        #fanout_index.append(i)\n",
    "    else:\n",
    "        gates_list.append(m[i])\n",
    "#input list       \n",
    "for i in range(len(m)):\n",
    "    if (m[i][0] == 'INPUT'):\n",
    "        for j in range(1,len(m[i])):\n",
    "            input_list.append(int(m[i][j]))\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "annual-television",
   "metadata": {},
   "outputs": [],
   "source": [
    "#get list of output wires\n",
    "output_wires=[]  #list of output wires\n",
    "for i in range(len(gates_list)):\n",
    "    output_wires.append(int(gates_list[i][1]))\n",
    "output_wires.sort(reverse = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "capital-proceeding",
   "metadata": {},
   "outputs": [],
   "source": [
    "#convert wires from str to int in wires\n",
    "wires=[]  #convert wires from str to int\n",
    "for i in range(len(m)):\n",
    "    for j in range(1,len(m[i])):\n",
    "        wires.append(int(m[i][j]))\n",
    "wires_list = list(set(wires)) #remove duplicate wires and convert it from set to list\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "institutional-creature",
   "metadata": {},
   "source": [
    "# SCOAP Controllability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "complete-container",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Controllability dictionaries (key=CC0|CC1:value=0)\n",
    "Controllability = []\n",
    "Values_CCO = []\n",
    "len(wires_list)\n",
    "for i in range(len(wires_list)):\n",
    "    CC0 = \"CC0_\"+str(i+1)\n",
    "    CC1 = \"CC1_\"+str(i+1)\n",
    "    Controllability.append(CC0)\n",
    "    Controllability.append(CC1)\n",
    "for j in range(len(Controllability)):\n",
    "    Values_CCO.append(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "covered-condition",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'CC0_1': 0,\n",
       " 'CC1_1': 0,\n",
       " 'CC0_2': 0,\n",
       " 'CC1_2': 0,\n",
       " 'CC0_3': 0,\n",
       " 'CC1_3': 0,\n",
       " 'CC0_4': 0,\n",
       " 'CC1_4': 0,\n",
       " 'CC0_5': 0,\n",
       " 'CC1_5': 0,\n",
       " 'CC0_6': 0,\n",
       " 'CC1_6': 0,\n",
       " 'CC0_7': 0,\n",
       " 'CC1_7': 0,\n",
       " 'CC0_8': 0,\n",
       " 'CC1_8': 0,\n",
       " 'CC0_9': 0,\n",
       " 'CC1_9': 0,\n",
       " 'CC0_10': 0,\n",
       " 'CC1_10': 0,\n",
       " 'CC0_11': 0,\n",
       " 'CC1_11': 0,\n",
       " 'CC0_12': 0,\n",
       " 'CC1_12': 0,\n",
       " 'CC0_13': 0,\n",
       " 'CC1_13': 0,\n",
       " 'CC0_14': 0,\n",
       " 'CC1_14': 0,\n",
       " 'CC0_15': 0,\n",
       " 'CC1_15': 0,\n",
       " 'CC0_16': 0,\n",
       " 'CC1_16': 0,\n",
       " 'CC0_17': 0,\n",
       " 'CC1_17': 0,\n",
       " 'CC0_18': 0,\n",
       " 'CC1_18': 0,\n",
       " 'CC0_19': 0,\n",
       " 'CC1_19': 0,\n",
       " 'CC0_20': 0,\n",
       " 'CC1_20': 0,\n",
       " 'CC0_21': 0,\n",
       " 'CC1_21': 0,\n",
       " 'CC0_22': 0,\n",
       " 'CC1_22': 0,\n",
       " 'CC0_23': 0,\n",
       " 'CC1_23': 0,\n",
       " 'CC0_24': 0,\n",
       " 'CC1_24': 0,\n",
       " 'CC0_25': 0,\n",
       " 'CC1_25': 0,\n",
       " 'CC0_26': 0,\n",
       " 'CC1_26': 0,\n",
       " 'CC0_27': 0,\n",
       " 'CC1_27': 0}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#zip key to value as control dictionary\n",
    "control = {key: value for key, value in zip(Controllability, Values_CCO)}\n",
    "control"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "embedded-gregory",
   "metadata": {},
   "outputs": [],
   "source": [
    "#copy all key to key_list\n",
    "key_list = []\n",
    "key_list = Controllability.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "compact-stuart",
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input as fanout wire number\n",
    "#return True or False\n",
    "def is_fanout(num):\n",
    "    c1=0\n",
    "    for j in range(len(fanout_list)):\n",
    "        for k in range(2,len(fanout_list[j])):\n",
    "            n2 = int(fanout_list[j][k])\n",
    "            if (n2==num):\n",
    "                c1=1\n",
    "            else:\n",
    "                pass\n",
    "    return c1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "eligible-health",
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input as fanout wire number\n",
    "#return fan_in\n",
    "def return_fanin(num):\n",
    "    c=0\n",
    "    for j in range(len(fanout_list)):\n",
    "        for k in range(2,len(fanout_list[j])):\n",
    "            n2 = int(fanout_list[j][k])\n",
    "            if (n2==num):\n",
    "                c = int(fanout_list[j][1])\n",
    "                return c\n",
    "            else:\n",
    "                pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "available-night",
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input as string and return split string\n",
    "def str_split(string):\n",
    "    temp = []\n",
    "    temp = string.split('_')\n",
    "    #num = int(temp[1])\n",
    "    return temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "typical-jacksonville",
   "metadata": {},
   "outputs": [],
   "source": [
    "#if n1 is input return 1 else return 0 | True or False\n",
    "def is_input_of_ckt(n1):\n",
    "    c=0\n",
    "    for i in range(len(input_list)):\n",
    "        if (input_list[i]==n1):\n",
    "            c=1\n",
    "        else:\n",
    "            pass\n",
    "    if (c==1):\n",
    "        return 1 \n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "sacred-lesson",
   "metadata": {},
   "outputs": [],
   "source": [
    "#make all inputs = 1  CC0_in = 1 and CC1_in = 1\n",
    "def make_input_1(str_split,is_input_of_ckt):\n",
    "    for i in range(len(key_list)):\n",
    "        str_list = str_split(key_list[i])\n",
    "        num = int(str_list[1])\n",
    "        num2 = is_input_of_ckt(num)\n",
    "        if (num2==1):\n",
    "            str1 = key_list[i]\n",
    "            control[str1] = 1\n",
    "        else:\n",
    "            pass\n",
    "        \n",
    "make_input_1(str_split,is_input_of_ckt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "dependent-meter",
   "metadata": {},
   "outputs": [],
   "source": [
    "#make fanout = fanin\n",
    "def fanout_equi(str_split,is_fanout,return_fanin,control1):\n",
    "    for i in range(len(key_list)):\n",
    "        str_list = str_split(key_list[i])\n",
    "        num = int(str_list[1])\n",
    "        str2 = str_list[0]\n",
    "        num2 = is_fanout(num)\n",
    "        if (num2==1):\n",
    "            num3 = return_fanin(num)\n",
    "            str1 = key_list[i]\n",
    "            str3 = str2+str('_')+str(num3)\n",
    "            num4 = control1[str3]\n",
    "            control1[str1] = num4 \n",
    "        else:\n",
    "            pass\n",
    "fanout_equi(str_split,is_fanout,return_fanin,control)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "radio-monkey",
   "metadata": {},
   "outputs": [],
   "source": [
    "#return 1 if number if output wire of gate else return 0\n",
    "def is_output_of_gate(num):\n",
    "    c2=0\n",
    "    for i in range(len(output_wires)):\n",
    "        if (output_wires[i] == num):\n",
    "            c2=1\n",
    "        else:\n",
    "            pass\n",
    "    return c2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "indian-melbourne",
   "metadata": {},
   "outputs": [],
   "source": [
    "#take output wire of gate as input and return GATE string \n",
    "def find_gate(gate_wire):\n",
    "    for i in range(len(gates_list)):\n",
    "        if (int(gates_list[i][1]) == gate_wire):\n",
    "            return gates_list[i][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "vulnerable-effects",
   "metadata": {},
   "outputs": [],
   "source": [
    "#take output wire of gate as inpur and return ['GATE', out, in1 ,in2]\n",
    "def find_gate_list(gate_wire):\n",
    "    for i in range(len(gates_list)):\n",
    "        if (int(gates_list[i][1]) == gate_wire):\n",
    "            return gates_list[i]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "classified-gamma",
   "metadata": {},
   "outputs": [],
   "source": [
    "#take output wire of gate as input and return [in1 , in2]\n",
    "def find_gate_input(find_gate_list,b):\n",
    "    g_list = find_gate_list(b)\n",
    "    i_list=[]\n",
    "    for i in range(2,len(g_list)):\n",
    "        i_list.append(int(g_list[i]))\n",
    "    return i_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "together-storm",
   "metadata": {},
   "outputs": [],
   "source": [
    "#input (GATE,CC0_a,CC1_a,CC0_a,CC1_b,control)\n",
    "#return list [CC0_z,CC1_z]\n",
    "def controllability_output_of_gate(gate,CC0_a,CC1_a,CC0_b,CC1_b,control):\n",
    "    z_out = []\n",
    "    a0 = control[CC0_a]\n",
    "    a1 = control[CC1_a]\n",
    "    b0 = control[CC0_b]\n",
    "    b1 = control[CC1_b]\n",
    "    z0 = 0\n",
    "    z1 = 1\n",
    "    if (gate =='AND'):\n",
    "        z0 = min(a0,b0) + 1\n",
    "        z1 = a1 + b1 + 1\n",
    "        z_out.append(z0)\n",
    "        z_out.append(z1)\n",
    "    elif (gate == 'OR'):\n",
    "        z0 = a0 + b0 + 1\n",
    "        z1 = min(a1,b1) + 1\n",
    "        z_out.append(z0)\n",
    "        z_out.append(z1)\n",
    "    elif (gate == 'NAND'):\n",
    "        z0 = a1 + b1 + 1\n",
    "        z1 = min(a0,b0) + 1\n",
    "        z_out.append(z0)\n",
    "        z_out.append(z1)\n",
    "    elif (gate =='NOR'):\n",
    "        z0 = min(a1,b1) + 1\n",
    "        z1 = a0 + b0 + 1\n",
    "        z_out.append(z0)\n",
    "        z_out.append(z1)\n",
    "    elif (gate =='XOR'):\n",
    "        z0 = min(a0+b0,a1+b1) + 1\n",
    "        z1 = min(a1+b0,a0+b1) + 1\n",
    "        z_out.append(z0)\n",
    "        z_out.append(z1)\n",
    "    elif (gate =='XNOR'):\n",
    "        z0 = min(a1+b0,a0+b1) + 1\n",
    "        z1 = min(a0+b0,a1+b1) + 1\n",
    "        z_out.append(z0)\n",
    "        z_out.append(z1)\n",
    "    else:\n",
    "        pass\n",
    "    return z_out\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "better-saskatchewan",
   "metadata": {},
   "outputs": [],
   "source": [
    "#main computing code\n",
    "output_wires.sort()\n",
    "for i in range(len(output_wires)):\n",
    "    out_wire = output_wires[i]\n",
    "    gate = find_gate(out_wire)\n",
    "    input_list_of_gate = find_gate_input(find_gate_list,out_wire)\n",
    "    a0_str = 'CC0_' + str(input_list_of_gate[0])\n",
    "    a1_str = 'CC1_' + str(input_list_of_gate[0])\n",
    "    b0_str = 'CC0_' + str(input_list_of_gate[1])\n",
    "    b1_str = 'CC1_' + str(input_list_of_gate[1])\n",
    "    z = controllability_output_of_gate(gate,a0_str,a1_str,b0_str,b1_str,control)\n",
    "    z0_str = 'CC0_' + str(out_wire)\n",
    "    z1_str = 'CC1_' + str(out_wire)\n",
    "    control[z0_str] = z[0]\n",
    "    control[z1_str] = z[1]\n",
    "    fanout_equi(str_split,is_fanout,return_fanin,control)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "bibliographic-quarterly",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CC0_1: 1\n",
      "CC1_1: 1\n",
      "CC0_2: 1\n",
      "CC1_2: 1\n",
      "CC0_3: 1\n",
      "CC1_3: 1\n",
      "CC0_4: 1\n",
      "CC1_4: 1\n",
      "CC0_5: 3\n",
      "CC1_5: 2\n",
      "CC0_6: 3\n",
      "CC1_6: 2\n",
      "CC0_7: 1\n",
      "CC1_7: 1\n",
      "CC0_8: 1\n",
      "CC1_8: 1\n",
      "CC0_9: 1\n",
      "CC1_9: 1\n",
      "CC0_10: 3\n",
      "CC1_10: 2\n",
      "CC0_11: 1\n",
      "CC1_11: 1\n",
      "CC0_12: 1\n",
      "CC1_12: 1\n",
      "CC0_13: 1\n",
      "CC1_13: 1\n",
      "CC0_14: 2\n",
      "CC1_14: 4\n",
      "CC0_15: 2\n",
      "CC1_15: 3\n",
      "CC0_16: 2\n",
      "CC1_16: 4\n",
      "CC0_17: 2\n",
      "CC1_17: 3\n",
      "CC0_18: 1\n",
      "CC1_18: 1\n",
      "CC0_19: 1\n",
      "CC1_19: 1\n",
      "CC0_20: 1\n",
      "CC1_20: 1\n",
      "CC0_21: 5\n",
      "CC1_21: 4\n",
      "CC0_22: 1\n",
      "CC1_22: 1\n",
      "CC0_23: 5\n",
      "CC1_23: 4\n",
      "CC0_24: 3\n",
      "CC1_24: 2\n",
      "CC0_25: 4\n",
      "CC1_25: 7\n",
      "CC0_26: 2\n",
      "CC1_26: 6\n",
      "CC0_27: 7\n",
      "CC1_27: 7\n"
     ]
    }
   ],
   "source": [
    "#printing Controlability\n",
    "for i in range(int(len(control)/2)):\n",
    "    i_val = i+1\n",
    "    print('CC0_' + str(i_val) +': ' + str(control['CC0_' + str(i_val)]))\n",
    "    print('CC1_' + str(i_val) +': ' + str(control['CC1_' + str(i_val)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "national-cycling",
   "metadata": {},
   "source": [
    "# SCOAP Observability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "portuguese-baghdad",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Observability dictionaries (key=CO_wire:value=0)\n",
    "Observability = []\n",
    "Values_CO = []\n",
    "len(wires_list)\n",
    "for i in range(len(wires_list)):\n",
    "    CO = \"CO_\"+str(i+1)\n",
    "    Observability.append(CO)\n",
    "for j in range(len(Observability)):\n",
    "    Values_CO.append(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "regional-immune",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'CO_1': 0,\n",
       " 'CO_2': 0,\n",
       " 'CO_3': 0,\n",
       " 'CO_4': 0,\n",
       " 'CO_5': 0,\n",
       " 'CO_6': 0,\n",
       " 'CO_7': 0,\n",
       " 'CO_8': 0,\n",
       " 'CO_9': 0,\n",
       " 'CO_10': 0,\n",
       " 'CO_11': 0,\n",
       " 'CO_12': 0,\n",
       " 'CO_13': 0,\n",
       " 'CO_14': 0,\n",
       " 'CO_15': 0,\n",
       " 'CO_16': 0,\n",
       " 'CO_17': 0,\n",
       " 'CO_18': 0,\n",
       " 'CO_19': 0,\n",
       " 'CO_20': 0,\n",
       " 'CO_21': 0,\n",
       " 'CO_22': 0,\n",
       " 'CO_23': 0,\n",
       " 'CO_24': 0,\n",
       " 'CO_25': 0,\n",
       " 'CO_26': 0,\n",
       " 'CO_27': 0}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#zip key to value in Observe Dictionary\n",
    "Observe = {key: value for key, value in zip(Observability, Values_CO)}\n",
    "Observe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "arctic-gentleman",
   "metadata": {},
   "outputs": [],
   "source": [
    "#copy all Observe key to list observe_list\n",
    "observe_list = []\n",
    "observe_list = Observability.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "prescribed-conversation",
   "metadata": {},
   "outputs": [],
   "source": [
    "#find output wire of the circuit\n",
    "def find_output_wire_of_ckt():\n",
    "    c = []\n",
    "    for i in range(len(out_in_fanout_list)):\n",
    "        if (out_in_fanout_list[i][0] == 'OUTPUT'):\n",
    "            for j in range(1,len(out_in_fanout_list[i])):\n",
    "                c.append(int(out_in_fanout_list[i][j]))\n",
    "        else:\n",
    "            pass\n",
    "    return c\n",
    "out_list = find_output_wire_of_ckt()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "conscious-refund",
   "metadata": {},
   "outputs": [],
   "source": [
    "#if n1 is output of ckt return 1 else return 0 | True or False\n",
    "def is_output_of_ckt(n1):\n",
    "    c=0\n",
    "    for i in range(len(out_list)):\n",
    "        if (out_list[i]==n1):\n",
    "            c=1\n",
    "        else:\n",
    "            pass\n",
    "    if (c==1):\n",
    "        return 1 \n",
    "    else:\n",
    "        return 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "spanish-clearance",
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input as Wire number\n",
    "#return fan_in True or False\n",
    "def is_fanin(num):\n",
    "    c1=0\n",
    "    for j in range(len(fanout_list)):\n",
    "        n2 = int(fanout_list[j][1])\n",
    "        if (n2==num):\n",
    "            c1=1\n",
    "        else:\n",
    "            pass\n",
    "    return c1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "corresponding-columbia",
   "metadata": {},
   "outputs": [],
   "source": [
    "#take input as wire number\n",
    "#return fan_out\n",
    "def return_fanout(num):\n",
    "    c=[]\n",
    "    for j in range(len(fanout_list)):\n",
    "        n2 = int(fanout_list[j][1])\n",
    "        if (n2 == num):\n",
    "            for k in range(2,len(fanout_list[j])):\n",
    "                n3 = int(fanout_list[j][k])\n",
    "                c.append(n3)\n",
    "            return c\n",
    "        else:\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "pregnant-washer",
   "metadata": {},
   "outputs": [],
   "source": [
    "#make output of the ckt = 1 | CO_out = 1\n",
    "def make_out_1(str_split,is_output_of_ckt):\n",
    "    for i in range(len(observe_list)):\n",
    "        string1 = str_split(observe_list[i])\n",
    "        numb = int(string1[1])\n",
    "        numb1 = is_output_of_ckt(numb)\n",
    "        if(numb1 == 1):\n",
    "            string2 = 'CO_' + str(numb)\n",
    "            Observe[string2] = 1\n",
    "        else:\n",
    "            pass\n",
    "make_out_1(str_split,is_output_of_ckt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "detailed-stocks",
   "metadata": {},
   "outputs": [],
   "source": [
    "#make fanin = min(fanout)\n",
    "def fan_in_equi(str_split,is_fanin,return_fanout,Observe1):\n",
    "    for i in range(len(observe_list)):\n",
    "        string1 = str_split(observe_list[i])\n",
    "        numb = int(string1[1])\n",
    "        numb2 = is_fanin(numb)\n",
    "        if (numb2 == 1):\n",
    "            numb3_list = return_fanout(numb)\n",
    "            string2 = observe_list[i]\n",
    "            b_list = []\n",
    "            for j in range(len(numb3_list)):\n",
    "                b1 = Observe1['CO_' + str(numb3_list[j])]\n",
    "                b_list.append(b1)\n",
    "        else:\n",
    "            pass\n",
    "        Observe1[string2] = min(b_list)\n",
    "\n",
    "fan_in_equi(str_split,is_fanin,return_fanout,Observe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "modern-treasure",
   "metadata": {},
   "outputs": [],
   "source": [
    "#return output wire of given input wire\n",
    "def return_out_of_in(in1):\n",
    "    for i in range(len(gates_list)):\n",
    "        for j in range(2,len(gates_list[i])):\n",
    "            nu1 = int(gates_list[i][j])\n",
    "            if (nu1 == in1):\n",
    "                nu2 = int(gates_list[i][1])\n",
    "                return nu2\n",
    "            else:\n",
    "                pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "aggregate-segment",
   "metadata": {},
   "outputs": [],
   "source": [
    "#take in1, corresponding output wire and return in2\n",
    "def return_other_in(find_gate_input,in1,out1):\n",
    "    in_list = find_gate_input(find_gate_list,out1)\n",
    "    temp_list = []\n",
    "    for i in range(len(in_list)):\n",
    "        if(in_list[i] == in1):\n",
    "            temp_list.append(in_list[i])\n",
    "        else:\n",
    "            pass\n",
    "    temp_list1 = list(set(in_list)-set(temp_list))\n",
    "    return temp_list1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "enclosed-basic",
   "metadata": {},
   "outputs": [],
   "source": [
    "#create gate_input_list and sort gate list in reverse order\n",
    "gate_in_list = []\n",
    "for i in range(len(gates_list)):\n",
    "    t1 = int(gates_list[i][2])\n",
    "    t2 = int(gates_list[i][3])\n",
    "    gate_in_list.append(t1)\n",
    "    gate_in_list.append(t2)\n",
    "gate_in_list.sort(reverse = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "purple-middle",
   "metadata": {},
   "outputs": [],
   "source": [
    "#input (GATE,'CC0_b','CC1_b',z) #z = Observe[CO_out]\n",
    "#output = observability calculation\n",
    "def observability_output_of_gate(gate,CC0_b,CC1_b,z):\n",
    "    b0 = control[CC0_b]\n",
    "    b1 = control[CC1_b]\n",
    "    za = 0\n",
    "    if (gate =='AND'):\n",
    "        za = z + b1 + 1\n",
    "    elif (gate == 'OR'):\n",
    "        za = z + b0 + 1\n",
    "    elif (gate == 'NAND'):\n",
    "        za = z + b1 + 1\n",
    "    elif (gate =='NOR'):\n",
    "        za = z + b0 + 1\n",
    "    elif (gate =='XOR'):\n",
    "        za = z + min(b0+b1) + 1\n",
    "    elif (gate =='XNOR'):\n",
    "        za = z + min(b0+b1) + 1\n",
    "    else:\n",
    "        pass\n",
    "    return za"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "forty-thing",
   "metadata": {},
   "outputs": [],
   "source": [
    "#main calculation of observability\n",
    "for i in range(len(gate_in_list)):\n",
    "    coa = 0\n",
    "    in_1 = gate_in_list[i]\n",
    "    out_1 = return_out_of_in(in_1)\n",
    "    in_2 = return_other_in(find_gate_input,in_1,out_1)\n",
    "    CC0_in2 = 'CC0_' + str(in_2)\n",
    "    CC1_in2 = 'CC1_' + str(in_2)\n",
    "    CO_out = 'CO_' + str(out_1)\n",
    "    CO_in1 = 'CO_' + str(in_1)\n",
    "    gate = find_gate(out_1)\n",
    "    z = Observe[CO_out]\n",
    "    coa = observability_output_of_gate(gate,CC0_in2,CC1_in2,z)\n",
    "    Observe[CO_in1] = coa\n",
    "    fan_in_equi(str_split,is_fanin,return_fanout,Observe)\n",
    "    \n",
    "fan_in_equi(str_split,is_fanin,return_fanout,Observe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "domestic-visiting",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CO_1: 12\n",
      "CO_2: 14\n",
      "CO_3: 14\n",
      "CO_4: 14\n",
      "CO_5: 12\n",
      "CO_6: 12\n",
      "CO_7: 13\n",
      "CO_8: 12\n",
      "CO_9: 12\n",
      "CO_10: 13\n",
      "CO_11: 14\n",
      "CO_12: 13\n",
      "CO_13: 13\n",
      "CO_14: 10\n",
      "CO_15: 10\n",
      "CO_16: 11\n",
      "CO_17: 11\n",
      "CO_18: 11\n",
      "CO_19: 11\n",
      "CO_20: 11\n",
      "CO_21: 7\n",
      "CO_22: 11\n",
      "CO_23: 8\n",
      "CO_24: 9\n",
      "CO_25: 4\n",
      "CO_26: 6\n",
      "CO_27: 1\n"
     ]
    }
   ],
   "source": [
    "#printing Observability\n",
    "for i in range(len(Observe)):\n",
    "    print('CO_' + str(i+1) +': ' + str(Observe['CO_' + str(i+1)]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "apparent-softball",
   "metadata": {},
   "source": [
    "# THANK YOU"
   ]
  }
 ],
 "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": 5
}