ca2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 style = \"font-size: 35px; text-align: center;\">AI CA2</h1>\n",
    "<h1 style = \"font-size: 35px; text-align: center;\">Decrypting encoded context using Genetic algorithms</h1>\n",
    "<h1 style = \"font-size: 32px; text-align: center; color: #666\">Taha Shabani 810196491</h1>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<h1 style = \"text-align: center\">Prelude</h1>\n",
    "<br>\n",
    "<h2>Definition of project:</h2>\n",
    "<p style = \"font-size: 14px\">First of all we have a training text stored in global_text.txt. after extracting its words, we receive an encoded file which is encoded_text.txt. The goal of the project is to find a dictionary of alphabets that can decode the ciphers and return the true context. <br>\n",
    "With a normal algorithm, the time order for this problem is 26! and it's almost impossible! So instead, we use a genetic algorithm to reach the goal.\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "\n",
    "<h1 style= \"text-align: center\">Prerequisites </h1>\n",
    "<br>\n",
    "<h3> 1. Reading input files: </h3>\n",
    "<p> Every input is a .txt file. files are read with <mark>readFile()</mark></p>\n",
    "\n",
    "<br>\n",
    "<h3> 2. Reading words and data cleaning: </h3>\n",
    "<p> <mark>GetListWords()</mark> extract all words from context (read file) and store them as a dictionary using <mark>getDictionary()</mark> with split() function from \"re\" library.\n",
    "<br>\n",
    "<p>All the uppercase characters convert to lowercase in order to simplifying algorithm and all the characters except alphabets are delimiters, for instance: '\\n', '-', numbers, and ...</p>\n",
    "<p>For example if we have \"hello\" 3 times in a text. we will find <mark>\"hello\" : 3</mark> in returned dictionary. </p>\n",
    "\n",
    "<br>\n",
    "<h3> 3. Other functions: </h3>\n",
    "<p> <mark>MakeDefaultDictionary()</mark> extract words considering uppercase characters too.</p>\n",
    "<p> <mark>SortSecond()</mark> is used to sort 2d list with second parameter as key.</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "from random import shuffle\n",
    "from random import randrange\n",
    "import random\n",
    "import math\n",
    "import time\n",
    "\n",
    "def readFile(fileName) :\n",
    "    file = open(fileName, 'r+')\n",
    "    fList = file.readlines()\n",
    "    file.close()\n",
    "    return fList;\n",
    "\n",
    "def getDictionary(words):\n",
    "    wordDic = {}\n",
    "    for word in words :\n",
    "        if (word in wordDic) :\n",
    "            wordDic[word] += 1\n",
    "        else: \n",
    "            wordDic[word] = 1\n",
    "    return wordDic           \n",
    "\n",
    "def getWords(context) :\n",
    "    words = re.split('[^a-zA-Z]', context)\n",
    "    words = list(filter(None, words))\n",
    "    return words\n",
    "\n",
    "def getListWords(context) :\n",
    "    words = [] \n",
    "    for row in context:\n",
    "        row = row.lower()\n",
    "        words += re.split('[^a-zA-Z]', row)\n",
    "        words = list(filter(None, words))\n",
    "    words = getDictionary(words)\n",
    "    return words\n",
    "def makeDefaultDictionary() :\n",
    "    encodedTxt = readFile(\"encoded_text.txt\")\n",
    "    encodedTxt = ''.join(encodedTxt)\n",
    "    return encodedTxt\n",
    "def makeDictoinaries():    \n",
    "    globalTxt = readFile(\"global_text.txt\")\n",
    "    encodedTxt = readFile(\"encoded_text.txt\")\n",
    "    for i in range(len(encodedTxt)) :\n",
    "        encodedTxt[i] = encodedTxt[i].lower()\n",
    "    globalWords = getListWords(globalTxt)\n",
    "    return [globalWords, encodedTxt]\n",
    "\n",
    "def sortSecond(val): \n",
    "    return val[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br>\n",
    "<h1 style= \"text-align: center\">Process steps </h1>\n",
    "<h2>Definition of chromosomes:</h2>\n",
    "<p>Each chromosome is a list which contains:</p>\n",
    "<p style=\"text-indent :2em;\"> [0]: 26 length string which maps alphabets to new ones.</p>\n",
    "<p style=\"text-indent :2em;\"> [1]: Value of fitness funciton for current chromosome.</p>\n",
    "<p>For example \"orsfwmbtizghknvelpdjcuyqax\" means that we map every \"a\", \"b\", and ... in encoded text with \"o\", \"r\", and ... respectively. note that priviously we lowered all characters in the text.</p>\n",
    "<br>\n",
    "\n",
    "<h2>Generating initial population:</h2>\n",
    "<p><mark>GetInitialChromosomes()</mark> is used to generate initial population. Population size for all generations is equal to 500.\n",
    "</p>\n",
    "<p>\n",
    "    In this function in order to have random initial chromosomes, we used <b>random</b> library and <b>sample()</b> to shuffle the origin chromosome: \"abcdefghijklmnopqrstuvwxyz\".\n",
    "</p>\n",
    "<p>Finally we sort chromosomes based on fitness value which means that index 0 of the list is the best fit chromosome.</p>\n",
    "\n",
    "<h2>Fitness function:</h2>\n",
    "<p><mark>GetFitness()</mark> uses <mark>calculateFitness()</mark> to calculates fitness for required chromosome:</p>\n",
    "<p style=\"text-indent :2em;\"> 1. Extract words from text decrypted with current chromosome.</p>\n",
    "<p style=\"text-indent :2em;\"> 2. Search each word in global words whether it exists or not.</p>\n",
    "<p style=\"text-indent :2em;\"><b> 3. Count the number of existing words and return it as fitness value.</b></p>\n",
    "<br>\n",
    "\n",
    "<h2>Crossover:</h2>\n",
    "<p><mark>Crossover()</mark> uses <mark>getcrossedStr()</mark> to generate 2 new children from 2 parents.</p>\n",
    "<p>First of all a list of parents is selected with <mark>chooseParants()</mark>. This function works like this:</p>\n",
    "<p style=\"text-indent :2em;\"> Choose (84% of 500) parents (we will explain it later) based on probabilities made with fitness value.</p>\n",
    "<p>Then I used a <b>position-based crossover</b> with <b>Pc = 0.65</b> and <b>points = 5</b> to generate children. Position-based crossover use k random points from first parent and fill other points by searching in second parent.</p>\n",
    "<br>\n",
    "\n",
    "<h2>Mutation:</h2>\n",
    "<p><mark>MutateNewChild()</mark> uses <mark>mutate()</mark> in order to swap at most two characters in chromosome:</p>\n",
    "<p style=\"text-indent :2em;\"> 1. generate a random number between 0 and 1 and check if it is less than <b>Pm = 0.2</b>.</p>\n",
    "<p style=\"text-indent :2em;\"> 2. if True: choose 2 points in chromosome and swap them and return new chromosome.</p>\n",
    "<p style=\"text-indent :2em;\"> 3. if False: don't make any changes in the chromosome.</p>\n",
    "<p><b>Note:</b>With this mutation function, it's probable to get stuck in local maximum but we solved this problem with \"restart\" after local max recognition, but how:\n",
    "<br>\n",
    "For mutation we had two solutions: <b>1. using one swap as described above. 2. using multiple swap (for example 1 per every character)</b>. First solution is much more faster based on experiments we've done, but local max problem is possible, so we've set a variable called <mark>restartLimitation = 120</mark> to check if during 120 iterations, best chromosome is still, restart the genetic algorithm with new random chromosomes, and it is still much more faster than solution 2. (in average about 6 times faster)</p>\n",
    "<br>\n",
    "\n",
    "<h2>Decode process:</h2>\n",
    "<p><mark>decode()</mark> uses <mark>generateNewGeneration()</mark> per every iteration to build the new generation.</p>\n",
    "<p>Iteration will continue until best chromosome is found.</p>\n",
    "<p><b>Best chromosome:</b> A chromosome which after decryption, all words are nown by training data.</p>\n",
    "<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<h1 style= \"text-align: center\">Issues</h1>\n",
    "<br>\n",
    "\n",
    "<h2>What if we increase population size during iterations?</h2>\n",
    "<p>Increase of the population size, above 100 chromosomes, does not improve the solution accuracy. Moreover, the computational time is increased significantly.</p>\n",
    "<br>\n",
    "\n",
    "<h2>What Is the effect of mutation? Would it be any problem if we use only crossover?</h2>\n",
    "<p>The most important effect of mutation is to generate new chromosomes using random abilities and to prevent getting stuck in local maximums or at least lower probability of it. So without mutation, we simply don't reach the goal because there would be a kind of bias in chromosomes after tens or hundreds iterations.</p>\n",
    "<br>\n",
    "\n",
    "<h2>Mutation or crossover, which one is more effective? Which one increases accuracy faster?</h2>\n",
    "<p>As we saw experimentally and as it's resonable, <b>mutation</b> is more effective because of the ability of generating new chromosomes even when chromosomes are similar.</p>\n",
    "<br>\n",
    "\n",
    "<h2>It's still possible to get stuch in local maxes though we use crossover and mutation. Why?</h2>\n",
    "<p>If the bias is too string, and it usually happens because of new generation process, mutation and crossover can not afford to change it. So here are some of the solutions:</p>\n",
    "    <p style=\"text-indent :2em;\"> 1. Increase probability of Pm and Pc.</p>\n",
    "    <p style=\"text-indent :2em;\"> 2. Extention of mutation to all characters.</p>\n",
    "    <p style=\"text-indent :2em;\"> 3. Use a simple algorithm with low complexity of time and restart it when it get stuch in local max.</p>\n",
    "    \n",
    "    \n",
    "<br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Decoder:\n",
    "    def __init__(self, encodedTxt, defaultEncodedTxt) : \n",
    "        self.encodedTxt = ''.join(encodedTxt)\n",
    "        self.defaultEncodedTxt = defaultEncodedTxt\n",
    "        self.numOfWords = len(getWords(self.encodedTxt))\n",
    "        self.restartLimitation = 120\n",
    "        self.popSize = 500\n",
    "        self.crossoverPoints = 5\n",
    "        self.elitismPercentage = 16\n",
    "        self.pc = 0.65\n",
    "        self.pm = 0.2\n",
    "        self.chromosomeSet = {}\n",
    "        self.chromosomes = self.getInitialChromosomes() #[0]: chromosome string, [1]: fitness value\n",
    "        self.chromosomes.sort(key = sortSecond, reverse = True)\n",
    "        \n",
    "        \n",
    "    def getInitialChromosomes(self) :\n",
    "        chromosomes = []\n",
    "        s = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "        newS = s\n",
    "        for i in range(self.popSize):\n",
    "            newS = ''.join(random.sample(newS,len(newS)))\n",
    "            fitnessScore = self.getFitness(newS)\n",
    "            chromosomes.append([newS, fitnessScore])\n",
    "            self.chromosomeSet[newS] = fitnessScore\n",
    "        return chromosomes\n",
    "    \n",
    "    def calculateFitness(self, words):\n",
    "        fitness = 0\n",
    "        for word in words :\n",
    "            if (word in globalWords) :\n",
    "                fitness += 1\n",
    "        return fitness\n",
    "                \n",
    "    def getFitness(self, s) :\n",
    "        alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "        tempEncoded = self.encodedTxt\n",
    "        for i in range(len(s)):\n",
    "            tempEncoded = tempEncoded.replace(alphabet[i], (s[i]).upper())\n",
    "        tempEncoded = tempEncoded.lower()\n",
    "        tempWords = getWords(tempEncoded)\n",
    "        fitnessScore = self.calculateFitness(tempWords)\n",
    "        return fitnessScore\n",
    "    \n",
    "    def getNewParent(self, sumOfFitnesses) : \n",
    "        randNum = randrange(sumOfFitnesses)\n",
    "        sumOfFitnesses = 0\n",
    "        for i in range(self.popSize) : \n",
    "            sumOfFitnesses += self.chromosomes[i][1]\n",
    "            if sumOfFitnesses >= randNum : \n",
    "                return self.chromosomes[i]\n",
    "            \n",
    "        index = randrange(self.popSize)\n",
    "        return self.chromosomes[index]     \n",
    "        \n",
    "    def chooseParants(self) : \n",
    "        parents = []\n",
    "        elitism = int(self.elitismPercentage/100 * self.popSize)\n",
    "        sumOfFitnesses = 0\n",
    "        for i in range(self.popSize) : \n",
    "            sumOfFitnesses += self.chromosomes[i][1]\n",
    "        for i in range(self.popSize - elitism) : \n",
    "            newParent = self.getNewParent(sumOfFitnesses)\n",
    "            parents.append(newParent)\n",
    "        shuffle(parents)\n",
    "        return parents\n",
    "    \n",
    "    def getcrossedStr(self, p1, p2, points):\n",
    "        usedChars1 = set()\n",
    "        child1 = [0] * len(p1)\n",
    "        for i in points : \n",
    "            child1[i] = p1[i]\n",
    "            usedChars1.add(p1[i])\n",
    "        i2 = 0\n",
    "        iChild = 0\n",
    "        while (len(usedChars1) <= len(p1)) : \n",
    "            if len(usedChars1) == len(p1) : \n",
    "                break\n",
    "            if (child1[iChild] != 0):\n",
    "                iChild += 1\n",
    "                continue\n",
    "            if (p2[i2] not in usedChars1) :\n",
    "                child1[iChild] = p2[i2]\n",
    "                usedChars1.add(p2[i2])\n",
    "                iChild += 1\n",
    "                i2 += 1\n",
    "                continue\n",
    "            if (p2[i2] in usedChars1) :\n",
    "                i2 += 1\n",
    "                continue\n",
    "        newChild = ''.join(child1)\n",
    "        return newChild\n",
    "    \n",
    "    def crossover(self, p1, p2) :\n",
    "        randomNum = random.uniform(0, 1)\n",
    "        if (randomNum <= self.pc) :    \n",
    "            points = random.sample(range(0, len(p1)), self.crossoverPoints)\n",
    "            child1 = self.getcrossedStr(p1, p2, points)\n",
    "            child2 = self.getcrossedStr(p2, p1, points)\n",
    "            return [child1, child2]\n",
    "        else:\n",
    "            return [p1, p2]\n",
    "        \n",
    "    def mutate(self, child) :\n",
    "        childList = re.findall(r\"[\\w']\", child)\n",
    "        newRand = random.uniform(0, 1)\n",
    "        if (newRand <= self.pm) :\n",
    "            points = random.sample(range(0, len(child)), 2)\n",
    "            tempChar = childList[points[0]]\n",
    "            childList[points[0]] = childList[points[1]]\n",
    "            childList[points[1]] = tempChar\n",
    "        newChild = ''.join(childList)\n",
    "        return newChild\n",
    "    def checkChild(self, child):\n",
    "        if (child in self.chromosomeSet) :\n",
    "            return [child, self.chromosomeSet[child]]\n",
    "        else :\n",
    "            return -1\n",
    "        \n",
    "    def mutateNewChild(self, child) :\n",
    "        newChild = self.mutate(child)  \n",
    "        repetitiveChild = self.checkChild(newChild)\n",
    "        newFitness = 0\n",
    "        if (repetitiveChild == -1) :\n",
    "            newFitness = self.getFitness(newChild)\n",
    "        else :\n",
    "            newFitness = repetitiveChild[1]\n",
    "        return [newChild, newFitness]\n",
    "                \n",
    "    def mateParentsAndGetChilds(self, parents) :\n",
    "        newGeneration = []\n",
    "        elitism = int(self.elitismPercentage/100 * self.popSize)\n",
    "        for i in range(elitism) : \n",
    "            newGeneration.append(self.chromosomes[i])\n",
    "        for i in range(int((self.popSize - elitism) / 2)) :\n",
    "            parent1 = parents[(i * 2) % (self.popSize)][0]\n",
    "            parent2 = parents[(i * 2 + 1) % (self.popSize)][0]\n",
    "            newChildren = self.crossover(parent1, parent2)\n",
    "            child1 = self.mutateNewChild(newChildren[0])\n",
    "            child2 = self.mutateNewChild(newChildren[1])\n",
    "            newGeneration.append(child1)\n",
    "            newGeneration.append(child2)   \n",
    "        newGeneration.sort(key = sortSecond, reverse = True)\n",
    "        return newGeneration\n",
    "    \n",
    "    def generateNewGeneration(self) : \n",
    "        newParents = self.chooseParants()\n",
    "        self.chromosomes = self.mateParentsAndGetChilds(newParents)\n",
    "    \n",
    "    \n",
    "    def printDecodedTxt(self, iteration) :\n",
    "        print(\"**** done ****\")\n",
    "        print(\"number of generations: \", iteration)\n",
    "        print(\"chromosome: \", self.chromosomes[0][0])\n",
    "        print(\"decoded text: \")\n",
    "        print()\n",
    "        defaultList = list(self.defaultEncodedTxt)\n",
    "        \n",
    "        s = self.chromosomes[0][0]\n",
    "        alphabet = \"abcdefghijklmnopqrstuvwxyz\"\n",
    "        tempEncoded = self.encodedTxt\n",
    "        for i in range(len(s)):\n",
    "            tempEncoded = tempEncoded.replace(alphabet[i], (s[i]).upper())\n",
    "        tempEncoded = tempEncoded.lower()\n",
    "        \n",
    "        answerList = s = list(tempEncoded)\n",
    "        \n",
    "        for i in range(len(defaultList)) : \n",
    "            if defaultList[i].isupper() :\n",
    "                answerList[i] = answerList[i].upper()\n",
    "        ansTxt = ''.join(answerList)\n",
    "        print(ansTxt)\n",
    "    \n",
    "    def printPercentage(self, previousMatched, currentMatched) : \n",
    "        prevPercentage = int (previousMatched / self.numOfWords * 100)\n",
    "        currPrecentage = int (currentMatched / self.numOfWords * 100)\n",
    "        progress = 0\n",
    "        if (currPrecentage >= 90 and prevPercentage < 90) : \n",
    "            progress = 90\n",
    "        elif (currPrecentage >= 80 and prevPercentage < 80) : \n",
    "            progress = 80 \n",
    "        elif (currPrecentage >= 70 and prevPercentage < 70) : \n",
    "            progress = 70 \n",
    "        elif (currPrecentage >= 60 and prevPercentage < 60) : \n",
    "            progress = 60 \n",
    "        elif (currPrecentage >= 50 and prevPercentage < 50) : \n",
    "            progress = 50 \n",
    "        elif (currPrecentage >= 40 and prevPercentage < 40) : \n",
    "            progress = 40 \n",
    "        elif (currPrecentage >= 30 and prevPercentage < 30) : \n",
    "            progress = 30 \n",
    "        elif (currPrecentage >= 20 and prevPercentage < 20) : \n",
    "            progress = 20 \n",
    "        elif (currPrecentage >= 10 and prevPercentage < 10) : \n",
    "            progress = 10 \n",
    "        if (progress > 0) :\n",
    "            print(progress, \"%\")\n",
    "         \n",
    "    def decode(self):\n",
    "        matchedWords = self.chromosomes[0][1]\n",
    "        iteration = 0\n",
    "        repeated = 0\n",
    "        print(\"decoding...\")\n",
    "        while (matchedWords < self.numOfWords) :\n",
    "            self.printPercentage(matchedWords, self.chromosomes[0][1])\n",
    "            if (self.chromosomes[0][1] == matchedWords) :\n",
    "                repeated += 1\n",
    "            else: \n",
    "                repeated = 0\n",
    "            if (repeated == self.restartLimitation) :\n",
    "                repeated = 0\n",
    "                print(\"restart...\")\n",
    "                self.chromosomes = self.getInitialChromosomes()\n",
    "                self.chromosomes.sort(key = sortSecond, reverse = True)\n",
    "            matchedWords = self.chromosomes[0][1]\n",
    "            self.generateNewGeneration()\n",
    "            iteration += 1\n",
    "        self.printDecodedTxt(iteration)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "decoding...\n",
      "20 %\n",
      "30 %\n",
      "40 %\n",
      "50 %\n",
      "60 %\n",
      "70 %\n",
      "80 %\n",
      "90 %\n",
      "**** done ****\n",
      "number of generations:  238\n",
      "chromosome:  orsfwmbtizghknvelpdjcuyqax\n",
      "decoded text: \n",
      "\n",
      "This response originally fell into a bit bucket.  I'm reposting it\n",
      "just so Bill doesn't think I'm ignoring him.\n",
      "\n",
      "In article <C4w5pv.JxD@darkside.osrhe.uoknor.edu> bil@okcforum.osrhe.edu (Bill Conner) writes:\n",
      ">Jim Perry (perry@dsinc.com) wrote:\n",
      ">\n",
      ">[Some stuff about Biblical morality, though Bill's quote of me had little\n",
      "> to do with what he goes on to say]\n",
      "\n",
      "Bill,\n",
      "\n",
      "I'm sorry to have been busy lately and only just be getting around to\n",
      "this.\n",
      "\n",
      "Apparently you have some fundamental confusions about atheism; I think\n",
      "many of these are well addressed in the famous FAQ.  Your generalisms\n",
      "are then misplaced -- atheism needn't imply materialism, or the lack\n",
      "of an absolute moral system.  However, I do tend to materialism and\n",
      "don't believe in absolute morality, so I'll answer your questions.\n",
      "\n",
      ">How then can an atheist judge value? \n",
      "\n",
      "An atheist judges value in the same way that a theist does: according\n",
      "to a personal understanding of morality.  That I don't believe in an\n",
      "absolute one doesn't mean that I don't have one.  I'm just explicit,\n",
      "as in the line of postings you followed up, that when I express\n",
      "judgment on a moral issue I am basing my judgment on my own code\n",
      "rather than claiming that it is in some absolute sense good or bad.\n",
      "My moral code is not particular different from that of others around\n",
      "me, be they Christians, Muslims, or atheists.  So when I say that I\n",
      "object to genocide, I'm not expressing anything particularly out of\n",
      "line with what my society holds.\n",
      "\n",
      "If your were to ask why I think morality exists and has the form it\n",
      "does, my answer would be mechanistic to your taste -- that a moral\n",
      "code is a prerequisite for a functioning society, and that humanity\n",
      "probably evolved morality as we know it as part of the evolution of\n",
      "our ability to exist in large societies, thereby achieving\n",
      "considerable survival advantages.  You'd probably say that God just\n",
      "made the rules.  Neither of us can convince the other, but we share a\n",
      "common understanding about many moral issues.  You think you get it\n",
      "from your religion, I think I get it (and you get it) from early\n",
      "childhood teaching.\n",
      "\n",
      ">That you don't like what God told people to do says nothing about God\n",
      ">or God's commands, it says only that there was an electrical event in your\n",
      ">nervous system that created an emotional state that your mind coupled\n",
      ">with a pre-existing thought-set to form that reaction. \n",
      "\n",
      "I think you've been reading the wrong sort of comic books, but in\n",
      "prying through the gobbledygook I basically agree with what you're\n",
      "saying.  I do believe that my mental reactions to stimuli such as \"God\n",
      "commanded the genocide of the Canaanites\" is mechanistic, but of\n",
      "course I think that's true of you as well.  My reaction has little to\n",
      "do with whether God exists or even with whether I think he does, but\n",
      "if a god existed who commanded genocide, I could not consider him\n",
      "good, which is supposedly an attribute of God.\n",
      "\n",
      ">All of this being so, you have excluded\n",
      ">yourself from any discussion of values, right, wrong, goood, evil,\n",
      ">etc. and cannot participate. Your opinion about the Bible can have no\n",
      ">weight whatsoever.\n",
      "\n",
      "Hmm.  Yes, I think some heavy FAQ-reading would do you some good.  I\n",
      "have as much place discussing values etc. as any other person.  In\n",
      "fact, I can actually accomplish something in such a discussion, by\n",
      "framing the questions in terms of reason: for instance, it is clear\n",
      "that in an environment where neighboring tribes periodically attempt\n",
      "to wipe each other out based on imagined divine commands, then the\n",
      "quality of life will be generally poor, so a system that fosters\n",
      "coexistence is superior, if quality of life is an agreed goal.  An\n",
      "absolutist, on the other hand, can only thump those portions of a\n",
      "Bible they happen to agree with, and say \"this is good\", even if the\n",
      "act in question is unequivocally bad by the standards of everyone in\n",
      "the discussion.  The attempt to define someone or a group of people as\n",
      "\"excluded from discussion\", such that they \"cannot participate\", and\n",
      "their opinions given \"no weight whatsoever\" is the lowest form or\n",
      "reasoning (ad hominem/poisoning the well), and presumably the resort\n",
      "of someone who can't rationally defend their own ideas of right,\n",
      "wrong, and the Bible.\n",
      "-- \n",
      "Jim Perry   perry@dsinc.com   Decision Support, Inc., Matthews NC\n",
      "These are my opinions.  For a nominal fee, they can be yours.\n",
      "\n",
      "-- \n",
      "Jim Perry   perry@dsinc.com   Decision Support, Inc., Matthews NC\n",
      "These are my opinions.  For a nominal fee, they can be yours.\n",
      "\n",
      "time:  33.76 sec\n"
     ]
    }
   ],
   "source": [
    "globalWords = makeDictoinaries()[0]\n",
    "encodedTxt = makeDictoinaries()[1]\n",
    "defaultEncodedTxt = makeDefaultDictionary()\n",
    "d = Decoder(encodedTxt, defaultEncodedTxt)\n",
    "start = time.time()\n",
    "d.decode()\n",
    "end = time.time()\n",
    "print(\"time: \", '%.2f'%(end - start), 'sec')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Conclusion</h2>\n",
    "<p>As it is clear, with genetic algorithm we reduce the complexity of 26! to a very better one. This is nature of genetic algorithms. But these algorithms are not always complete or optimal and dut to that, we must handle its issues. We used third solution (simple algorithm and restart) because we tested all 3 solutions and the 3'rd works the best.</p>\n",
    "<br>"
   ]
  },
  {
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}