Molecular computing.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "mounted-destiny",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import random\n",
    "\n",
    "complete = {\"a\":\"t\", \"t\": \"a\", \"g\":\"c\",\"c\":\"g\"}\n",
    "getComplete = lambda info: ''.join(map(lambda x: complete[x],info))\n",
    "\n",
    "class DNA_strand:\n",
    "    def __init__(self, genInfo, completeInfo = \"\"):\n",
    "        self.genInfo = genInfo\n",
    "        if completeInfo == \"\":\n",
    "            self.completeInfo = getComplete(genInfo)\n",
    "        else:\n",
    "            self.completeInfo = completeInfo\n",
    "        \n",
    "    def isSame(self, DNA_strand):\n",
    "        return DNA_strand.genInfo ==  getComplete(self.genInfo)\n",
    "    \n",
    "    def mix(self, seq):\n",
    "        if np.random.choice([1, 1, 1, 1, 1, 1, 1, 1, 1, 0]) == 1:\n",
    "            self.genInfo += seq.genInfo\n",
    "            self.completeInfo += seq.completeInfo\n",
    "    \n",
    "class DNA_lab:\n",
    "    def __init__(self, strandArray = []):\n",
    "        self.strandArray = strandArray\n",
    "    \n",
    "    def extract(self, specificStrand = [], Partially = False):\n",
    "        if Partially:\n",
    "            res = []\n",
    "            for j in self.strandArray:\n",
    "                for i in specificStrand:\n",
    "                    if i in j.genInfo:\n",
    "                        res.append(j)\n",
    "                        break\n",
    "        else:\n",
    "            res = list(filter(lambda strand: strand.genInfo in specificStrand,self.strandArray))\n",
    "        self.strandArray = res\n",
    "        return res\n",
    "    \n",
    "    def length_sort(self):\n",
    "        return sorted(self.strandArray, key=lambda x: len(x.genInfo), reverse=True)\n",
    "    \n",
    "    def Amplify(self,sequence, CycleNum = 1):\n",
    "        prev = [sequence]\n",
    "        for i in range(CycleNum):\n",
    "            new_prev = []\n",
    "            for seq in prev:\n",
    "                if np.random.choice([1, 1, 1, 1, 1, 1, 1, 1, 1, 0]) == 1:\n",
    "                    new_prev.append(DNA_strand(seq.genInfo))\n",
    "                    new_prev.append(DNA_strand(getComplete(seq.completeInfo)))\n",
    "            prev = new_prev\n",
    "            \n",
    "        self.strandArray  += prev\n",
    "        return prev\n",
    "    \n",
    "    def sequence(self,index):\n",
    "        return strandArray[index].genInfo\n",
    "    \n",
    "    def cleave(seq, subSeq, i1, i2):\n",
    "        self.strandArray.remove(seq)\n",
    "        part1 , part2 = None, seq\n",
    "        while True:\n",
    "            try:\n",
    "                index = part2.genInfo.index(subSeq)\n",
    "                part1, part2 = DNA_strand(part2.genInfo[:index+i1], part2.completeInfo[:index+i2]) , DNA_strand(part2.genInfo[index+i1:], part2.completeInfo[index+i2:])\n",
    "                self.strandArray.append(part1)\n",
    "            except:\n",
    "                self.strandArray.append(part2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "artistic-biography",
   "metadata": {},
   "outputs": [],
   "source": [
    "def getUnique(sat):\n",
    "    unique = []\n",
    "    for i in sat:\n",
    "        for j in i:\n",
    "            if j[-1] not in unique:\n",
    "                unique.append(j[-1])\n",
    "    return unique\n",
    "\n",
    "def getVertexes(array):\n",
    "    new = []\n",
    "    for i in range(1,len(array)+2):\n",
    "        new.append('a'+str(i))\n",
    "    array.sort()\n",
    "    return array + new + list(map(lambda x: '-' + x, array))\n",
    "\n",
    "def getEdges(vertex):\n",
    "    counter = 1\n",
    "    edges = []\n",
    "    for v in vertex:\n",
    "        if 'a' not in v and '-' not in v:\n",
    "            if 'a'+str(counter) in vertex:\n",
    "                edges.append(('a'+str(counter),v))\n",
    "                edges.append(('a'+str(counter),'-'+v))\n",
    "                edges.append((v,'a'+str(counter+1)))\n",
    "                edges.append(('-'+v,'a'+str(counter+1)))\n",
    "                counter += 1\n",
    "    return edges\n",
    "\n",
    "def BuildGraph(sat):\n",
    "    v = getVertexes(getUnique(sat))\n",
    "    e = getEdges(v)\n",
    "    return {'V': v, 'E': e}\n",
    "\n",
    "def truthTable(sat):\n",
    "    length =  len(getUnique(sat))\n",
    "    limit = 2**(length)\n",
    "\n",
    "    result = np.zeros((limit, length))\n",
    "\n",
    "    for i in range(length-1,-1,-1):\n",
    "        IsOne = True\n",
    "        for j in range(limit):\n",
    "            if j % 2**i == 0 and j!= 0:\n",
    "                IsOne = not IsOne\n",
    "        \n",
    "            if IsOne:\n",
    "                result[j,length - i - 1] = 1\n",
    "            else:\n",
    "                result[j,length - i -1] = 0\n",
    "\n",
    "    return pd.DataFrame(result, columns = getUnique(sat))\n",
    "\n",
    "sat = [\n",
    "    [\"w\",\"x\",\"y\"],\n",
    "    [\"w\",\"y\",\"-z\"],\n",
    "    [\"w\",\"-y\",\"z\"],\n",
    "    [\"-w\",\"-x\",\"-z\"]\n",
    "]\n",
    "\n",
    "Graph = BuildGraph(sat)\n",
    "TruthTable = truthTable(sat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "apart-adoption",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After C1 (len = 14):\n",
      "\n",
      "['w', 'x', 'y', 'z']\n",
      "['w', 'x', 'y', '-z']\n",
      "['w', 'x', '-y', 'z']\n",
      "['w', 'x', '-y', '-z']\n",
      "['w', '-x', 'y', 'z']\n",
      "['w', '-x', 'y', '-z']\n",
      "['w', '-x', '-y', 'z']\n",
      "['w', '-x', '-y', '-z']\n",
      "['-w', 'x', 'y', 'z']\n",
      "['-w', 'x', 'y', '-z']\n",
      "['-w', 'x', '-y', 'z']\n",
      "['-w', 'x', '-y', '-z']\n",
      "['-w', '-x', 'y', 'z']\n",
      "['-w', '-x', 'y', '-z']\n",
      "\n",
      "After C2 (len = 13):\n",
      "\n",
      "['w', 'x', 'y', 'z']\n",
      "['w', 'x', 'y', '-z']\n",
      "['w', 'x', '-y', 'z']\n",
      "['w', 'x', '-y', '-z']\n",
      "['w', '-x', 'y', 'z']\n",
      "['w', '-x', 'y', '-z']\n",
      "['w', '-x', '-y', 'z']\n",
      "['w', '-x', '-y', '-z']\n",
      "['-w', 'x', 'y', 'z']\n",
      "['-w', 'x', 'y', '-z']\n",
      "['-w', 'x', '-y', '-z']\n",
      "['-w', '-x', 'y', 'z']\n",
      "['-w', '-x', 'y', '-z']\n",
      "\n",
      "After C3 (len = 11):\n",
      "\n",
      "['w', 'x', 'y', 'z']\n",
      "['w', 'x', 'y', '-z']\n",
      "['w', 'x', '-y', 'z']\n",
      "['w', 'x', '-y', '-z']\n",
      "['w', '-x', 'y', 'z']\n",
      "['w', '-x', 'y', '-z']\n",
      "['w', '-x', '-y', 'z']\n",
      "['w', '-x', '-y', '-z']\n",
      "['-w', 'x', 'y', 'z']\n",
      "['-w', 'x', '-y', '-z']\n",
      "['-w', '-x', 'y', 'z']\n",
      "\n",
      "After C4 (len = 9):\n",
      "\n",
      "['w', 'x', 'y', '-z']\n",
      "['w', 'x', '-y', '-z']\n",
      "['w', '-x', 'y', 'z']\n",
      "['w', '-x', 'y', '-z']\n",
      "['w', '-x', '-y', 'z']\n",
      "['w', '-x', '-y', '-z']\n",
      "['-w', 'x', 'y', 'z']\n",
      "['-w', 'x', '-y', '-z']\n",
      "['-w', '-x', 'y', 'z']\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def GetPaths(df):\n",
    "    paths = {}\n",
    "    for index, row in df.iterrows():\n",
    "        path = []\n",
    "        for i, v in enumerate(row):\n",
    "            if v == 1:\n",
    "                path.append((\"a\"+str(i+1),df.columns[i]))\n",
    "                path.append((df.columns[i],\"a\"+str(i+2)))\n",
    "            else:\n",
    "                path.append((\"a\"+str(i+1),\"-\"+df.columns[i]))\n",
    "                path.append((\"-\"+df.columns[i],\"a\"+str(i+2)))\n",
    "        paths[index] = path\n",
    "    return paths\n",
    "        \n",
    "def Vertex2Seq(G):\n",
    "    res = {}\n",
    "    for v in G['V']:\n",
    "        res[v] = ''.join(random.choices(['a','t','c','g'], weights = [1,1, 1, 1], k = 20))\n",
    "    return res\n",
    "\n",
    "def Path2Seq(path,V2S):\n",
    "    result = V2S[path[0][0]]\n",
    "    for i in path:\n",
    "        result += V2S[i[1]]\n",
    "    return result\n",
    "\n",
    "def Seq2Path(seq,V2S):\n",
    "    res = []\n",
    "    S2V = {list(V2S.values())[i]: list(V2S.keys())[i] for i in range(len(V2S.keys()))}\n",
    "    for i in range(0,len(seq.genInfo),20):\n",
    "        res.append(S2V[seq.genInfo[i:i+20]])\n",
    "    return res\n",
    "        \n",
    "paths = GetPaths(TruthTable)\n",
    "V2S = Vertex2Seq(Graph)\n",
    "\n",
    "strandArray = []\n",
    "\n",
    "for path in paths.values():\n",
    "    strandArray.append(DNA_strand(Path2Seq(path,V2S)))\n",
    "    \n",
    "DNALab = DNA_lab(strandArray)\n",
    "\n",
    "for i,C in enumerate(sat):\n",
    "    seq = list(map(lambda x: V2S[x], C))\n",
    "    DNALab.extract(seq, True)\n",
    "    print(\"After C{} (len = {}):\\n\".format(i+1,len(DNALab.strandArray)))\n",
    "    for strand in DNALab.strandArray:\n",
    "        print(Seq2Path(strand,V2S)[1:-1:2])\n",
    "    print(\"\")"
   ]
  }
 ],
 "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}