CSI4506-FuzzyLogic-Fall20.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook 1 - Logique Floue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "CSI4506 Intelligence Artificielle  \n",
    "Automne 2020  \n",
    "Preparé par Julian Templeton, Caroline Barrière et Joel Muteba"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***INTRODUCTION***:   \n",
    "Nous examinerons un exemple d’application de la logique floue à un problème en utilisant la programmation. Au début du notebook, des variables linguistiques qui representeront les composantes du problème seront définies. Ces variables seront utilisées parallèlement à des règles spécifiques pour résoudre un problème. Cela se fait par l’utilisation de la fuzzification, l’application de règles d’inférence ou raisonnement, et la défuzzification du résultat.\n",
    "\n",
    "Le système de logique floue que nous construisons aidera une personne à décider de l’activité à faire et de sa durée. Cela dépendra de la proximité à la fin de semaine et du degré d'occupation de la personne. Les trois activités possibles sont: faire du yoga, jouer à des jeux et faire du ski. Les règles floues que nous définirons dans notre système de logique floue s’appliqueront à deux antécédents possibles (deux variables linguistiques) Day et Busy. Une vue d’ensemble est indiquée ci-dessous dans l’image 1.\n",
    "\n",
    "![image.png](attachment:image.png)    \n",
    "\n",
    "En effectuant tous les composants de base d’un système logique flou pour résoudre un problème, vous améliorerez votre compréhension de la façon dont la logique floue peut être appliquée aux problèmes du monde réel et comment chaque composant d’un système logique flou fonctionne.    \n",
    "\n",
    "Une note importante à garder à l’esprit lorsque vous passerez au travers du notebook est qu’il y a des classes avec une quantité importante de code, mais vous aurez seulement besoin d'**utiliser les fonctions de la classe LinguisticVariable** lors de l’exécution d’une étape qui utilise une variable de cette classe. Ainsi, ne soyez pas intimidé par la quantité de lignes de codes puisque vous aurez juste besoin d’appeler les fonctions appropriées quand cela sera nécessaire.    \n",
    "\n",
    "La bibliothèque matplotlib sera utilisée pour ce notebook. C'est une excellente bibliothèque graphique. La bibliothèque vous permet de créer de nombreux types de graphes à partir de vos données et de les personnaliser. Pour installer matplotlib, exécutez la commande suivante dans votre console : *pip install matplotlib*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***TRAVAIL À FAIRE***:  \n",
    "\n",
    "Parcourez le notebook en exécutant chaque cellule, une à la fois. Si l'exécution d'une cellule cause une erreur, vous pouvez résoudre le problème et ré-exécuter cette cellule.  \n",
    "Recherchez **(TO DO)** pour les tâches que vous devez effectuer. Une fois que vous avez terminé, soumettez votre notebook. \n",
    "\n",
    "*Le notebook sera noté sur 30.  \n",
    "Chaque **(TO DO)** a un certain nombre de points qui lui sont associés.*\n",
    "***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "# Call pip install matplotlib in the console to install this library\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1. Définition d'une variable linguistique.**    \n",
    "\n",
    "Une variable linguistique est représentée par son nom, ses valeurs possibles et ses sous-ensembles flous. Cela peut être représenté par un triplet (V, X, T). Les classes ci-dessous définissent chaque composante d’une variable linguistique. Le constructeur de la classe LinguisticVariable accepte son nom (V du triplet) et les noms des valeurs associées à la variable sous la forme d’une liste (X du triplet). Les sous-ensembles flous (T dans le triplet) sont ajoutés après la définition de la variable linguistique.     \n",
    "\n",
    "Une note importante au sujet de cette classe est que les valeurs possibles qui sont transmises à l’objet LinguisticVariable peuvent être de deux types :\n",
    "1. [name1, name2, name3, ..., nameN], où chaque nom est une valeur discrète associée à la variable et sont tous des strings\n",
    "2. [(num1, num2]], où num1 et num2 sont des entiers qui représentent un interval continu de nombres réels sous la forme d’un tuple     \n",
    "\n",
    "Ces valeurs possibles sont stockées dans la liste possible_values de la classe LinguisticVariable et sont ensuite transmises à la liste value_names de la classe Values.    \n",
    "\n",
    "Une autre remarque est que la classe Values stocke une liste d’équations mathématiques sous la variable *function*. Il s’agit d’une liste d’expressions lambda qui exécutent des fonctions mathématiques. Cette liste de fonctions doit avoir la même longueur que la liste des value_names. Cela permet à la liste value_names et à la liste des fonctions de contenir les informations associées dans le même index.\n",
    "\n",
    "Ex: value_names[0] --> Mardi\n",
    "    functions[0] --> lambda x: 0.0\n",
    "    Par conséquent, lorsque nous voulons trouver la valeur floue pour le mardi à une certaine valeur x, nous appelons functions[0](x) pour obtenir cette valeur          \n",
    "    \n",
    "La classe FuzzySubset contient de nombreux fonctionnalités de base qui seront utilisés dans notebook. Toutefois, vous n’aurez qu’à appeler des fonctions de la classe LinguisticVariable pour éviter la manipulation d’éléments enfants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DO NOT MAKE ANY CHANGES TO THIS CLASS\n",
    "# You will be asked to call the methods of this class, but NOT to change it\n",
    "\n",
    "class LinguisticVariable():\n",
    "    '''\n",
    "    Represents a linguistic variable that contains a name, a set of values for this variable,\n",
    "    and fuzzy subsets for the values that are used to characterise this variable.\n",
    "    '''\n",
    "    def __init__(self, variable_name, values):\n",
    "        # The name of a variable\n",
    "        self.variable_name = variable_name\n",
    "        # A list of all value names\n",
    "        self.possible_values = values\n",
    "        # The fuzzy suvbsets that characterize variable_name\n",
    "        self.fuzzy_subsets = []\n",
    "        \n",
    "    def add_fuzzy_subset(self, name, functions):\n",
    "        '''\n",
    "        Defines a fuzzy_subset of the specified name and defines functions\n",
    "        for each value pass into the constructor.\n",
    "        The functions are expected to be in the same order as the values that they are for.\n",
    "        Ex: [val1, val2, ...], [function_for_val1, function_for_val2, ...]\n",
    "        '''\n",
    "        self.fuzzy_subsets.append(FuzzySubset(name, self.possible_values, functions))\n",
    "        \n",
    "    def fuzzification(self, fs_name, x):\n",
    "        '''\n",
    "        Finds the fuzzy subset with the specified name (fs_name) and fuzzifies the value x\n",
    "        '''\n",
    "        fs_index = [fs.name.lower() for fs in self.fuzzy_subsets].index(fs_name.lower()) \n",
    "        return self.fuzzy_subsets[fs_index].fuzzification(x)\n",
    "    \n",
    "    def defuzzification_average_maximas(self, fs_name):\n",
    "        '''\n",
    "        By going through each value (increments of 0.5 for continuous variables), returns the average\n",
    "        x-location for the defuzzification of the transfered membership max_membership\n",
    "        '''\n",
    "        fs_index = [fs.name.lower() for fs in self.fuzzy_subsets].index(fs_name.lower())\n",
    "        return self.fuzzy_subsets[fs_index].defuzzification_average_maximas()\n",
    "    \n",
    "    def get_fuzzy_maximum(self, fs_name):\n",
    "        '''\n",
    "        Finds the fuzzy subset with the specified name (fs_name) and returns its maximum\n",
    "        membership degree.\n",
    "        '''\n",
    "        fs_index = [fs.name.lower() for fs in self.fuzzy_subsets].index(fs_name.lower()) \n",
    "        # Return its maximum membership\n",
    "        return self.fuzzy_subsets[fs_index].max_membership\n",
    "    \n",
    "    def set_fuzzy_maximum(self, fs_name, x):\n",
    "        '''\n",
    "        Finds the fuzzy subset with the specified name (fs_name) and assigns x to be its maximum\n",
    "        membership degree (transfers the membership to this fuzzy subset).\n",
    "        '''\n",
    "        fs_index = [fs.name.lower() for fs in self.fuzzy_subsets].index(fs_name.lower()) \n",
    "        # Since max_membership is already set to the maximum available y value, only update if\n",
    "        # x is < the current value.\n",
    "        if (x < self.fuzzy_subsets[fs_index].max_membership):\n",
    "            self.fuzzy_subsets[fs_index].max_membership = x\n",
    "        \n",
    "    def reset_fuzzy_maximums(self):\n",
    "        '''\n",
    "        When a problem is complete, this will reset the maximum_membership values\n",
    "        for all fuzzy variables back to the maxima in its function\n",
    "        '''\n",
    "        for fs in self.fuzzy_subsets:\n",
    "            if (fs.values.isRangedVariable):\n",
    "                fs.max_membership = self.reset_fuzzy_maximum_ranged(fs)\n",
    "            else:\n",
    "                fs.max_membership = self.reset_fuzzy_maximum_discrete(fs)\n",
    "            \n",
    "    def reset_fuzzy_maximum_discrete(self, fs):\n",
    "        '''\n",
    "        Returns the maxima for a fs that describes discrete variable\n",
    "        '''\n",
    "        vals = [] # The values for each value\n",
    "        # Go through the values associated with the fuzzy subset\n",
    "        for value in fs.values.value_names:\n",
    "            vals.append(fs.fuzzification(value))\n",
    "        # Set the variable's fuzzy subset maximum to be the maximum value in the plot\n",
    "        return max(vals)\n",
    "        \n",
    "    def reset_fuzzy_maximum_ranged(self, fs):\n",
    "        '''\n",
    "        Returns the maxima for a fs that describes a range of real numbers\n",
    "        '''\n",
    "        for fs in self.fuzzy_subsets:\n",
    "            vals = []\n",
    "            # Determine the number of points to compute\n",
    "            start = fs.values.value_names[0][0]\n",
    "            stop = fs.values.value_names[0][1] + 1\n",
    "            # Compute the points and store them\n",
    "            # Increment by 0.05 to capture most changes\n",
    "            for i in range(start, stop):\n",
    "                # Can use libraries to make this easier, that is somthing we will explore in future notebooks\n",
    "                for j in range(0, 20):\n",
    "                    x = i + j * 0.05\n",
    "                    vals.append(fs.fuzzification(x))\n",
    "            # Set the variable's fuzzy subset maximum to be the maximum value in the plot\n",
    "            return max(vals)\n",
    "        \n",
    "    def plot(self):\n",
    "        '''\n",
    "        Plots a linguistic variable and automatically detects the type of values that\n",
    "        it contains\n",
    "        '''\n",
    "        if (self.fuzzy_subsets[0].values.isRangedVariable):\n",
    "            self.plot_ranged_variable()\n",
    "        else:\n",
    "            self.plot_discrete_variable()\n",
    "    \n",
    "    def plot_discrete_variable(self):\n",
    "        '''\n",
    "        Plots the linguistic variable if the values are discrete\n",
    "        '''\n",
    "        fig = plt.figure()\n",
    "        axes = fig.add_axes([0, 0, 1, 1])\n",
    "        x_vals = [] # The lavels on the x-axis\n",
    "        plot_values = [] # The values for each value\n",
    "        y_label = \"Variable \" + self.variable_name\n",
    "        # Go through the fuzzy subsets (only one in this notebook)\n",
    "        fs = self.fuzzy_subsets[0]\n",
    "        # Go through the values associated with the fuzzy subset\n",
    "        for value in fs.values.value_names:\n",
    "            x_vals.append(value)\n",
    "            plot_values.append(fs.fuzzification(value))\n",
    "        # Set the variable's fuzzy subset maximum to be the maximum value in the plot\n",
    "        self.fuzzy_subsets[0].max_membership = max(plot_values)\n",
    "        # Add the values to the plot\n",
    "        axes.bar(x_vals, plot_values)\n",
    "        # Show the plot\n",
    "        plt.show()\n",
    "    \n",
    "    def plot_ranged_variable(self):\n",
    "        '''\n",
    "        Plots the linguistic variable if the values are a range\n",
    "        '''\n",
    "        x_label = \"Number of hours\" # Fixed in this notebook, otherwise would add to the tuple\n",
    "        y_label = \"Variable \" + self.variable_name\n",
    "        for fs in self.fuzzy_subsets:\n",
    "            x_points = []\n",
    "            y_points = []\n",
    "            # Determine the number of points to compute\n",
    "            start = fs.values.value_names[0][0]\n",
    "            stop = fs.values.value_names[0][1] + 1\n",
    "            # Compute the points and store them\n",
    "            # Increment by 0.05 to capture most changes\n",
    "            for i in range(start, stop):\n",
    "                # Can use libraries to make this easier, that is somthing we will explore in future notebooks\n",
    "                for j in range(0, 20):\n",
    "                    x = i + j * 0.05\n",
    "                    x_points.append(x)\n",
    "                    y_points.append(fs.fuzzification(x))\n",
    "            # Set the variable's fuzzy subset maximum to be the maximum value in the plot\n",
    "            fs.max_membership = max(y_points)\n",
    "            # Add the points to the plot\n",
    "            plt.plot(x_points, y_points, label=fs.name)\n",
    "        # Add the labels\n",
    "        plt.xlabel(x_label)\n",
    "        plt.ylabel(y_label)\n",
    "        # Define the limits of the plot\n",
    "        axes = plt.gca()\n",
    "        axes.set_xlim([self.fuzzy_subsets[0].values.value_names[0][0], self.fuzzy_subsets[0].values.value_names[0][1]])\n",
    "        axes.set_ylim(0, 1.1)\n",
    "        # Add a grid to the plot\n",
    "        plt.grid()\n",
    "        # Add a legend to the plot\n",
    "        plt.legend()\n",
    "        # Show the plot\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DO NOT MAKE ANY CHANGES TO THIS CLASS\n",
    "# This class is used by the LinguisticVariable class.  You will NOT make any calls to this class.\n",
    "\n",
    "class Values():\n",
    "    '''\n",
    "    Stores the names of the values and a list of functions that describe the value for a fuzzy subset.\n",
    "    values: A list of the names of the values. If a numerical range, the list will only contain\n",
    "            a tuple of the form [(num1, num2)] to represent the range between num1 and num2.\n",
    "            Otherwise it will be of the form [name1, name2, ..., nameN].\n",
    "            Assumes that discrete items are strings (so if a number, store as a string)\n",
    "    '''\n",
    "    def __init__(self, value_names, functions):\n",
    "        # True if the first element is a tuple of two integers (num1, num2)\n",
    "        self.isRangedVariable = False\n",
    "        if type(value_names[0]) is tuple:\n",
    "            self.isRangedVariable = True\n",
    "        # The names or range of the values\n",
    "        self.value_names = value_names\n",
    "        # The functions used to compute values for each value (if range, an equation)\n",
    "        # The index is the same as the value index\n",
    "        self.functions = functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DO NOT MAKE ANY CHANGES TO THIS CLASS\n",
    "# This class is used by the LinguisticVariable class.  You will NOT make any calls to this class.\n",
    "\n",
    "class FuzzySubset():\n",
    "    '''\n",
    "    Represents a single fuzzy subset.\n",
    "    Accepts a name, list of values, and list of lambda equations as input.\n",
    "    The values are stored as a Values object which also contain the functions that the\n",
    "    fuzzy subset maps to each value.\n",
    "    The max_membership parameter represents the maximum membership value that can be given\n",
    "    at a given point in time.\n",
    "    '''\n",
    "    def __init__(self, name, values, functions):\n",
    "        self.name = name\n",
    "        self.values = Values(values, functions)\n",
    "        self.max_membership = 1\n",
    "        \n",
    "    def fuzzification(self, x):\n",
    "        '''\n",
    "        Returns the membership value for the value x\n",
    "        x: The value to be used\n",
    "        '''\n",
    "        membership = -1\n",
    "        if self.values.isRangedVariable:\n",
    "            # If a range, then x is the value within the range\n",
    "            membership = self.values.functions[0](x)\n",
    "        else:\n",
    "            # If not a range, then x represents the index for the appropriate value\n",
    "            value_index = [val.lower() for val in self.values.value_names].index(x.lower()) \n",
    "            membership = self.values.functions[value_index](0)\n",
    "        return membership\n",
    "    \n",
    "    def defuzzification_average_maximas(self):\n",
    "        '''\n",
    "        Using the max_membership value, finds all values >= that value since they are the\n",
    "        maximas after the transferring of membership degree.\n",
    "        Loops through all key points in the plot (since it can be a continuous value) and\n",
    "        averages the x values that are >= max_membership\n",
    "        '''\n",
    "        x_points = []\n",
    "        # Determine the number of points to compute\n",
    "        start = self.values.value_names[0][0]\n",
    "        stop = self.values.value_names[0][1] + 1\n",
    "        # Compute the points and store all maxima x-values\n",
    "        # Increment by 0.05 to capture most changes\n",
    "        for i in range(start, stop):\n",
    "            # Can use libraries to make this easier, that is somthing we will explore in future notebooks\n",
    "            for j in range(0, 20):\n",
    "                x = i + j * 0.05\n",
    "                # Store only if the y-value is a maxima\n",
    "                if self.fuzzification(x) >= self.max_membership:\n",
    "                    x_points.append(x)\n",
    "        # Return the average of all x-values\n",
    "        return sum(x_points) / len(x_points)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. Création des objets LinguisticVariable.**\n",
    "\n",
    "Avec les définitions de classe ci-dessus, nous sommes maintenant en mesure de définir les différentes variables linguistiques qui seront utilisées dans ce notebook. Les variables suivantes seront définies :   \n",
    "1. *Day*: Les valeurs sont les jours de la semaine et il n’y a qu’un seul fuzzy_subset (sous-ensemble flou) nommé *Weekend*. C’est un antécédent.\n",
    "2. *Busy*: Les valeurs sont toutes des nombres réels dans l'interval [0, 10], représentant le nombre d’heures et il y a trois sous-ensembles flous {Little, Moderate, Very}. C’est un antécédent.\n",
    "3. *Activity*: Les valeurs sont toutes des nombres réels dans la plage [0, 10], représentant le nombre d’heures et il y a actuellement deux sous-ensembles flous {Ski, Yoga} (vous définirez un troisième plus tard). C’est une conséquence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La première variable linguistique à définir est pour la variable Day. Ci-dessous, vous avez toutes les étapes pour définir la variable (définir les valeurs, les variables floues et définir les fonctions pour faire correspondre une variable floue à chaque valeur)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Weekend membership for the value Thursday is 0.3\n"
     ]
    }
   ],
   "source": [
    "# Start by defining the values (each dayy of the week)\n",
    "day_values = [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"]\n",
    "# Define the Day linguistic variable\n",
    "day_lv = LinguisticVariable(\"Day\", day_values)\n",
    "# Begin defining the functions for the Weekend fuzzy subset (a function for each value)\n",
    "day_functions = []\n",
    "# For Sunday\n",
    "day_functions.append(lambda x: 0.95)\n",
    "# For Monday\n",
    "day_functions.append(lambda x: 0.0)\n",
    "# For Tuesday\n",
    "day_functions.append(lambda x: 0.0)\n",
    "# For Wednesday\n",
    "day_functions.append(lambda x: 0.0)\n",
    "# For Thursday\n",
    "day_functions.append(lambda x: 0.3)\n",
    "# TODO: See (TODO) Q1 below\n",
    "# For Friday\n",
    "day_functions.append(lambda x: 0.7)\n",
    "# For Saturday\n",
    "day_functions.append(lambda x: 1.0)\n",
    "# Setup the Weekend fuzzy element in the linguistic variable\n",
    "day_lv.add_fuzzy_subset(\"Weekend\", day_functions)\n",
    "\n",
    "# Show the value for Thursday\n",
    "chosenDay = \"Thursday\"\n",
    "# For the first fuzzy subset (weekend), what is the membership of Thursday?\n",
    "chosenDayMembership = day_lv.fuzzy_subsets[0].fuzzification(\"Thursday\")\n",
    "print(\"The Weekend membership for the value \" + chosenDay + \" is \" + str(chosenDayMembership))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avec la variable linguistique *day_lv* définie, nous allons la tracer pour voir le graphique"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the linguistic variable\n",
    "day_lv.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(TO DO) Q1 - 1 point** \n",
    "\n",
    "Dans day_lv vous voyez que le vendredi est considéré comme week-end à 0,5 (valeur d'adhésion ou membership sur l'échelle définie plus haut).  C’est trop bas, puisque vendredi est proche du week-end.  Modifiez le code ci-dessus (et réexécutez la cellule) pour que le vendredi soit condidéré comme week-end à 0,7."
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(TO DO) Q2 - 3 points** \n",
    "\n",
    "Avec day_lv défini, nous devons maintenant définir busy_lv pour la variable linguistique *Busy*. En suivant les modèles de code ci-dessous, continuez la définition de busy_lv.   \n",
    "\n",
    "Rappelez-vous que selon la description définie au début de la section 2, cette variable utilise une valuer continue dans un interval. Ces values_names sont définis par un seul tuple d’entiers [(num1, num2)] plutôt qu’une liste de strings.\n",
    "\n",
    "La figure suivante (*Image 2*) montre à quoi doit ressembler le ggraphe de la variable linguistique Busy lorsque vous exécutez la cellule suivante. Vous devrez compléter la définition de busy_lv en trouvant la fonction correcte à passer pour le sous-ensemble de floue *Very*. Des exemples de la façon dont ces équations mathématiques sont définies et ajoutées sont indiqués ci-dessous (les expressions lambda).\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 10)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Define the Busy linguistic variable\n",
    "busy_values = [(0, 10)]\n",
    "# TODO: Define the linguistic variable busy_lv\n",
    "busy_lv = LinguisticVariable(\"Busy\", busy_values)\n",
    "busy_functions = []\n",
    "\n",
    "# Define functions for the Little fuzzy set\n",
    "# For (0, 10)\n",
    "busy_functions = [lambda x: -x+3 if 2<=x<=3 else (1 if 0<=x<=2 else 0)]\n",
    "# Setup the Little fuzzy element\n",
    "busy_lv.add_fuzzy_subset(\"Little\", busy_functions)\n",
    "\n",
    "# Define functions for the Moderate fuzzy set\n",
    "# For (0, 10)\n",
    "busy_functions = [lambda x: (x-2)/2 if 2<=x<=4 else ((-x+7)/2 if 5<=x<=7 else (1 if 4<=x<=5 else 0))]\n",
    "# Setup the Moderate fuzzy element\n",
    "busy_lv.add_fuzzy_subset(\"Moderate\", busy_functions)\n",
    "\n",
    "# TODO: Setup the Very busy function and add that fuzzy set\n",
    "# Define functions for the Very fuzzy set\n",
    "# For (0, 10)\n",
    "busy_functions = [lambda x: (x-6)/2 if 6<=x<=8 else(1 if 8<=x<=10 else 0)]\n",
    "# Setup the Very fuzzy element\n",
    "busy_lv.add_fuzzy_subset(\"Very\" , busy_functions)\n",
    "\n",
    "# Show an example output\n",
    "print(busy_lv.fuzzy_subsets[0].values.value_names[0])\n",
    "busy_lv.fuzzy_subsets[0].values.functions[0](0.1234345)\n",
    "\n",
    "# Plot the graph\n",
    "busy_lv.plot()"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEKCAYAAAAIO8L1AAAgAElEQVR4Ae19B5hURda23+7+z+63667upxhWXQXEgGQkGcgiAiJiQlQUMSGIWZGcBARBkuQ45MwwmTDkPOQhMzPkYWCAGWZgmIDv/5y63L4dbnff231DdXfV8/R03boVznmrpt6udOo2CCcQEAgIBAQCAgEVBG5TCRNBAgGBgEBAICAQgCAI0QgEAgIBgYBAQBUBQRCqsIhAgYBAQCAgEBAEIdqAQEAgIBAQCKgiIAhCFRYRKBAQCAgEBAKCIEQbEAgIBAQCAgFVBARBqMIiAgUCAgGBgEBAEIRoAwIBgYBAQCCgioAgCFVYRKBAQCAgEBAIhBxB3HHHHahevbr4VK+OJ554QuBwqy0ILJT/CYGFwEKtj7z77rt1M17IEcRjjz2mW8lwTbBmzZpwVU23XgILBTKBhcBCQUDxEWnodYIg9CLGUXzRESiVIbAQWCgIKD7RLhQsBEEoWESETzR+pZoFFgILBQHFJ9qFgoUgCAWLiPCJxq9Us8BCYKEgoPhEu1CwEAShYBERPtH4lWoWWAgsFAQUn2gXChaCIBQsIsInGr9SzQILgYWCgOIT7ULBQhCEgkVE+ETjV6pZYCGwUBBQfKJdKFgIglCwiAifaPxKNQssBBYKAopPtAsFC0EQChYR4RONX6lmgYXAQkFA8Yl2oWAhCELBIiJ8ovEr1SywEFgoCCg+0S4ULARBKFhEhE80fqWaBRYCCwUBxSfahYKFIAgFi4jwicavVLPAQmChIKD4RLtQsBAEoWARET7R+JVqFlgILBQEFJ9oFwoWgiAULCLCJxq/Us0CC4GFgoDiE+1CwUIQhIJFRPhE41eqWWAhsFAQUHyiXShYcEUQ7du3R6lSpfDUU08pEjr5/vjjD3zxxRcoW7YsKlasiJ07dzq99e4V5r4VbETjF1goCCg+0S4EFgoCio8rgli3bh3r9L0RRFxcHJo2bQoiii1btqBmzZqKJj58giAUcERHILBQEFB8ol0ILBQEFB9XBEFiZWRkeB1BfPLJJ5gzZ45Deur4z50753j25hEEoSAjOgKBhYKA4hPtQmChIKD4Qoogmjdvjg0bNjikb9iwIXbs2OF49uaJCIK4eRNYNwS4csobDCxcdAQKPAILCYvFO0/jnVGJ+HbBHts/7efORZOZHW39PD/xA1vLt1t/5/JDiiCaNWvmQRApKSnKf7yTb8KECY67l2ldgzqDcP7sXDYW6P0vZEz9yKeeMTExPt+HM0buugks1mDg7JV4+MdYVOgRg2q942z/VBrzDipMq4QKk5+z7zPJxrLt1Nut7KemVWJ9qFO3qslr6pWjYopJUx14RlrZmxEEol71fOcUQp2kcBICkY5FyolLKNc9Hm+O34yVq5O5aBZdVnfBq9G+27DZgkZ6u5DxrTS5XmgRRGxsrMsidY0aNWRdfH5HxBTT77Ulghj0X+CPP7ziIRq/Ak0kY3Hq0jVU67cC9YYk43J+IRtVKsjY5/ts5Wd4K+Yt+wQAuMHCVhAAVJrcgC+CaNOmDe677z785S9/wQMPPIDJkydj3Lhx7ENg0e6lzz//HGXKlEGFChU0rT9QurAniMsnJHIYU0v6zj7utW1FcqfoDkqkYpFbUITGw9aiYu9EHL+Qx2DhBYsOiR3wXvx77lVl6TMvWFiqtEphlSc35IsgVGQ0JCjsCWLbRIkYUpdK33vne8VNNH4FmkjEorjkJt6dvBVlf4rDpuMXHWDwgsW7ce+CSMJOxwsWdmJAZVee3EgQhN2VYEj5M18DRlYFSoqBAfcB8T94zVY0fgWaSMSi57L9bFF63vaTChAcTau8GfMmOq7s6CKb1Q+R2C7UMK4yubEgCDVgQiqsMB/oVwpI+EkSe+pLwKRGXlUQjV+BJtKwmLYxnZHDwLiDCgi3fLxg0WpZK3yZ/KWHfFYG8IKFlTqrlVVlchNBEGrAhFTYoThpWiltrSR2UneJMIoLVdUQjV+BJZKwSD6UhdJdY/HxjB24edNzEwMvWDRf0hzfr/1eqSQbfLxgYYPqLkVWndJUEIQLIqH4EP0F8PMDgEwIqUskwjijbqdKNH6lkiMFi0OZuXiqVyKajVyPa4XFCgBOPl6waLywMbpt6OYkmfVeXrCwXnPXEqtOeUkQhCskIfZE21mHPgbMd9r1ceWkRBC0cK3iRONXQIkELLKuFuCZQatR8+eVyMwpUJR38/GCRd15ddF3c1836ax95AULa7X2LK3alGaCIDxhCaGQs7slMtg9WxGaSGNIWWDJZ0qYk080fgWMcMeioKgEr4zZiCd6JGD/mRxFcRUfL1jUmV0Hg7YNUpHQuiBesLBOY/WSqk9pLghCHZoQCV0zGOh9B5B3wVXg2W8Bo9UPEYrGr0AVzljQOkOn2TvxSNdYJKZmKkp78fGCRfWZ1TFsxzAvUloTzAsW1mjrvZTqU14WBOEdnhB4M6G++o6ltUMk4ijw/NUoGr9Sr+GMxbCkw2zH0vi13g9NKkjwcXqYDsJWmF4Bo3aNchbNcn84tws9YD495RVBEHoA4ypuXpY0vUQWXN3dsVXSuzRPu0ui8StghSsWS3adZuTw/cI9zPqAorF3Hw9YFJUUMYIYv2e8d0EteMMDFhao6beIGlNaCYLwixKvEXbNlEggc5+nhNcuSe/W/+rxTjR+BZJwxGJ7xiWU6xaPNhO2oLD4pqKsHx8PWOQX5TOCmLZ/mh9pzX3NAxbmaqgt95pTXxUEoQ0qDmPNewcY9qR3w3x0snpuWw/BReNXIAk3LE5mX0PVfivQYOgaXLmmfg5G0d7VxwMWlwsuM4KYdXCWq3AWP/GAhcUqqxZXc2prQRCqyPAeWHwD+Pk/wHIfJ04Xfwz8+riHJqLxK5CEExY514vQaNhaVOqThPSL+YqSGn08YHE+/zwjiAVHFmiU2pxoPGBhjmb6cq019XVBEPog4yT28dXSFNLhBO8CbR0vxck54xJHNH4FjnDBouiWAb5Hu8Vh8/FsRUEdPh6wOJV7ihHEsmPLdEhufFQesDBeK/051p76hiAI/bBxkIKM8fW/Byi85l2Y0zskgjgQ7RJHNH4FjnDAgnb+dFuyjy1Kz9/h+7pZRXNPHw9YHL9ynBFEQrqPHz6eohsewgMWhisVQIZ1prURBBEAbvYmoYNwv1UEZr3hW46iAqDvXcCKXi7xRONX4AgHLKZskAzwDYo/pCgWgI8HLA5mH2QEserkqgA0MC4JD1gYp03gOT0z7W1BEIHDZ1PKC4elkcH2yf4FmFAPmNbcJZ5o/AocoY7F6kPnmQG+T6NSVA3wKZr69/GAxZ4LexhBrD+93r/AJsbgAQsT1dOc9bPT2gqC0IwWLxE3jry1tnDav0Sx30qG/G6WOOKKxu+AIqSvljx4LhfleyagxagNXg3wKZr69/HQLrZnbmcEsfXcVv8CmxiDByxMVE9z1s9Nf1cQhGa0eIk4tRkw9llt0uyeI5FJlmL/XzR+BbpQxSIrtwB1Bq5CrZ9X4XyudwN8iqb+fTxgsfHMRkYQu7N2+xfYxBg8YGGiepqzfn76e4IgNKPFQ8Trl4E+/wZW9dMmzYUjEkHQobpbTjR+GQk+zEso0mjzXS8sQcvRGzQZ4NOWoxSLh3aRfDKZEURqdqoe0Q2PywMWhisVQIZ1p7cTBBEAbvYl2bdQ6vBPbdMmw82bwMAHgZivHPFF43dAEXJTTGSAr+OsFGaAb8WB84oiBvh4aBeJGYmMII5ePmqARoFnwQMWgUtvXMr6Mz4QBGEcnBbktOgj4JfSgNOagt9Sp78MjH/eEU00fgcUIUcQQxMlA3wT16UpShjk46FdLD++nBHEidwTBmkVWDY8YBGY5MamajDjQ0EQxkJqYm4lxcDgh4Eln+orZFVfoO//AUXXWTrR+BX4QgmLRSmSAb6ui/dqNsCnaOrfxwMWi44sYgSRme/fPLl/jQKPwQMWgUtvXMqGUR8JgjAOTpNzOrFZml6iK0X1uEOxLtNSovEr4IUKFtvSL4FOSb89cQvo1LQZjgcs5hyawwgi+3pgp8GNwoUHLIzSJZh8GkV9LAgiGAAtTUsH3mgkoHLHg085rmZKBLH5dxZNNH4FrVDAIuNiPqr0TUKDX9cg51qRIrzBPh6wmJ46nRHE1cKrBmunLzsesNAnsTmxG0d9KgjCHGhNyPX32sD0FoFlTFZfF37I0orGr0DIOxZECEQMlfsmgYjCTMcDFhP3TmQEcaPkhpmq+s2bByz8CmlBhBdmfiYIwgKcgy/i8olbo4AxgeVFpsFHVGZpReNXIOQZC5pKajtpC5ta2ppm/pQLD1iM2T2GEQTZl7LT8YCFnfrLZb8483NBEDIYXH9vmygRRLa26yM9dNnwm5T+2qWQ27njoYuBAbx2BNRBdl0sGeBbmKLhxLwBmPCAxfCU4agaVdUAbYLLggcsgtPAmNRNZ3UWBGEMlCbnMrM1MKpa4IWkr5cI4uhKQRBOKPLaEUxan8ass/6SEJwBPidV/Xp5wGLwtsGoNbuWX1nNjsADFmbrqCX/ZrO/EAShBShb49zIA/rdDST8FLgYN64Cve8A1gwSBOGEIo8dAR2Ae6RrLDsQRwfjrHI8YNF/S388P1c5s2OV7u7l8ICFu0x2PDef/aUgCDuA11WmvE01ba2uZB6Rx9QCZr0uCMIJGN46gtSzOXiyZwIzpUEmNax0PGDRY2MPNFrQyEq1VcviAQtVwSwObDHnK0EQFmOuv7jozpK5jGJ9dwx7FLT0c3YKe01ysserSA3gqSMgA3y1B65iRvjIb7XjAYsf1v2Alxa/ZLXqHuXxgIWHUDYEtJzzDX8EkZCQgMceewxly5bFoEGDPGA5efIk6tevjypVqqBixYqIi4vziOMeQPmFpKPdHEMfA+a3C178HVPYOsSW+HnB5xUmOfDSEdBo4eXRG9jo4cDZXFvQ5QGLr9d8jVeWvmKL/s6F8oCFszx2+V+Z+x1fBFFSUoIyZcogLS0NhYWFqFSpEg4cOOCCz8cff4yxY8eyMHr38MMPu7xXewhZgji7W1pcJrPdwbpze1heqfM1WoINtrwQSM9DR0DrDHThD607rDTYAJ+eKuABi06rOuGN5X5uStSjVIBxecAiQNENTfbq3B/4IojNmzejSZMmDiUHDhwI+ji7Tz75BIMHD2ZBFL9OnTrOr1X9IUsQawZLi8v5F1X10hVYUsTusT416V1dycI5Mg8dweCEQ2zHEu1cstPxgMVHSR+hbVxbO2FgZfOAhe0gAGg970e+CGLhwoXo0KGDA5uoqCh06tTJ8Uyec+fOoUKFCnjggQdw5513IiUlxeW92kPIEsSE+sCkxmoqBRY2+QXkDLN/G2Fgwhufyu6OYMGOU4wcflqyzxQDfHoQsxsLkrVdfDu0T2yvR2xT4vKAhSmK6cz09fk/8UUQCxYs8CCIzp07u6g1bNgw/PrrryyMRhBPPvkkbtK9B25uwoQJTLnq1aujVKlSbPcOVXyofDYlLmFTQmnTPzdM5lOT3kFJ37uxdrV0HiJUsDBLzpiYGMOw1SvjuMWrUKZrLJoNicfK1cm2ySHLbScWsgzN5zTHG/PeEFhw0k81nczZOQgtU0zly5fHqVOnHHRQunRpZGVlOZ7VPCE5gtgZJa0/ZO5TUymwMPnCoXN7A0sfZqmoY7LDpV/MZ/aVGpIBvuvmGeDTo5tdWDjL+Fr0a+i82vUHofN7q/w8YGGVrr7KeWtBD75GEMXFxaAOPz093bFInZrqev1g06ZNMW3aNKbXwYMHcf/99/sdnockQcxtC5CRPSPt0lxKl0hnx1Rf7SJi3tnREVy5VogGQ9cwC60nss01wKenIu3Awl2+Fkta4Js137gHW/7MAxaWK61S4NsLe/JFECQjbVstV64c2800YMAAJnbPnj0RHR3N/LRz6ZlnnmE7nCpXroykpCQV1VyDQo4gim8AA+53uSrUVaMAn/74A0X9HwCWfR5gBuGVzOqOoLD4JtpM2IJy3eKxPeMSV2BajYWa8i8uehE/rQ/CYoBapgGE8YBFAGIbnuSdRX34IwjDtQTYuQoz8jUtz2OrpF/6RxINLyJ7ZAOATIcLx+a6rYKBDPD9sHAvW5ResssaA3x6dOOhU2wwvwF6b+qtR2xT4vKAhSmK6cz03UX9BEHoxMya6PE/AP3vdVwTamShGVM/kbbOkn2mCHdWdgQT1h1n5PBr0mEuUbcSC28APDv3WQzYIs0aeItjRTgPWFihp78y2i0eIAjCH0iWv6c1h98qArPfNKXovYt+lUYnGRtMyT+UMrWqI0hMzWQH4T6fvRNWGuDTUxdWYeFLphqzamDI9iG+oljyjgcsLFHUTyEfLPlZEIQfjKx/feHwrYXkKaaUvTEpWsp/4whT8g+lTK3oCPafycETPRLQcsxGFBRZa4BPT11YgYU/eSrPqIyRO0f6i2b6ex6wMF1JDQV8uHSQIAgNOFkbhTru3v8Ccs6YUi5r/CMqAfPEiWqzO4LMnALU/Hklnhm0GllXrTfAp6cBmY2FP1lKbpaw2+TG7pHM6PiLb+Z7u7EwUzc9eXdYNtgcgmjdujViY2NVD7DpEdCouCG1i2nqS8DYZ41S3SMf1vgXtgeGlfd4F2kBZnYE1wqL0XzUepTvmYCD5+wxwKenPs3EQosc14uvM4KYvG+yluimxrEbC1OV05H5J9FDzSGIlStXom3btmyr6o8//ohDh6y7GUtN/5AhiGuXgD7/BlaZZ1CPNf7NY6RRytVMNbgiJsysjoDWGT6esQOlu8Yi+ZDvQ5y8gG0WFlr1y7mRwwgi6kCU1iSmxbMbC9MU05nxZ8uHmUMQshw5OTkYN24cHnzwQWZUb+rUqSgqsv7kaMgQhHzS+dR2GULDv1njP7lVIohD/k2lGy4ARxma1REMjD/IdixN3ZjOkba+RTELC9+lKm8vXLvACGL+4flKoE0+u7GwSW2PYjsuH24eQWRnZ2PEiBGsgJdffhnz5s0D2VWqV6+ehyBmB4QMQSzqAPxSBrhp3mIma/xF100fqZhdp0bkb0ZHMG/7SUYO3Zfab4BPD0ZmYKGn/DN5ZxhBLDm6RE8yU+LajYUpSgWQaacYqf/Wm/Q2fwleffVVZkSPTHWT9VVnR8bzrHYhQRAlxcCg/wJLPjMVHkfjH/ccMKOlqWXxnrkDC4ME3XT8Isr+FId3J29FcYmnAUmDijElG6Ox0Ctkek46I4jYtFi9SQ2PbzcWhisUYIZfxI4yZwShdsvbjRs3AhQz+GQhQRAnNkvTPqlLg1fYRw6Oxr/8S2DgQ4CKJVwfycPqlQMLA7RKu5CHSn2S0HjYWuQWWD+NGqwKRmIRiCyHLx1mBLHixIpAkhuaxm4sDFUmiMy+jB9jDkFUrVrVQyy1MI9IJgWEBEGs6AX0/T+gwNwdL47GL1uLvXjUJNT5z9aBRZCikgG++kPXoFq/FTh16VqQudmT3CgsApV+34V9jCDWnV4XaBaGpbMbC8MUCTKjbxLGGksQmZmZ7AKfJ554Art27cLOnTvZhwB//PHHgxQ38OQhQRBjagHTXw5cSY0pHY0/66A0YtkzV2PK8IvmwCII1cgA35vjNzMDfCkn+DLAp0ctI7DQU5573JTzKYwgNp/d7P7K8me7sbBcYS8Ffpc43liCmD59OurXr4/bb7+dfZOfPrRIvXjxYi9imB/MPUFczpA6a9p+arJzNH5aCP/5P0DcdyaXyG/2DiwCFJEM8H23YA9blF66y5yDjQGKpjtZsFjoLtAtARFDhekVQERht7MbC7v1l8v/IXGisQQhZ7xo0SLZy8U39wSxdYJEENnHTcfLpfFPaw7QtaYR6lywCACDsWskA3zDVhwJIDVfSYLFIlhtaGqJCIKmmux2dmNht/5y+T8lTTaWIGbOnMnypitB6WpQ949csNXf3BNE1KvAqGqWwOLS+Ff0BPreBdD9ExHoXLDQqX/C/nNs5NB5zi6/F1bpzNqW6MFgEYzANApLPpkMuguCbDGdy3Pd9RhM3oGmtQuLQOU1K123FVOMJYjx48czWfv06QO1j1mK+MuXa4K4kQf0uxtI7OZPDUPeuzT+A8ukkctp+4f1hiinMxMXLHSk3Xc6B4/3iEer3/k2wKdDJUvvxpDlysjJwKcrP2Ujh5ZLW2LLuS3yK1u/A20XtgptQuE9Vk4zliBkGS9cuCB7ufjmmiAOxkiddLo1uzdcGj8ZBCTDgDTFFYHOBQuN+p/LuY4aAyQDfBeuhs/IKxAsNELmES2/KB/DUoahSlQV1J5dGzNSZ6DoJj9bg63EwgMcjgL6rI4yhyAeffRRvPDCC5g8eTIuX75su8pcE0R0Z2Dgg0CJNf8gLo2f7p4Y+hiw+BPb68gOAVyw0CBA/o1ivDRiPZ7qlYjDmeF14ZJeLDTA5RGFppNi0mJAN8fRekP3Dd1x8fpFj3h2B1iBhd06aim/b/JMcwiCCt+2bRu+/vprlC5dGs2bN4e8PqFFMKPjcEsQdEiNOugF7xutstf8PBr/nLctW//wKpRNLzyw8CFHyc0/0GG6ZIBvzeHQMMDnQx2PV3qw8EisIeDQpUNoF9+OEcNbMW9hz4U9GlLZE8VsLOzRSn+pA9bMNo8gZHEuXryI9957D3/605/kIMu/uSWIs7ukKR4LzyJ4NP51QyUZrts/0rO6YXhg4UOAn+MkA3zTN2X4iBW6r/RgoUdLstLaf0t/VJpRCc/PfR6LjizCzT/4NkNiFhZ6cOMh7sC188whiNzcXNCZiKZNm6JcuXL44Ycf2AE6u5TmliDWDJLuh87Ptgwaj8Z/PFkiiOOrLZOBl4I8sPAi2NxtkgG+Xsv2e4kR+sFasdCqKV0ARJZZn5v7HCOHn7f+DCKLUHBGYxEKOqvJ+Mu6+eYQxCOPPIKvvvoKmzfbfyqSFOeWICbUAyY1Vqsb08I8Gn9BjkQQ6+y/C9g0pb1k7IGFSryNxyQDfO2mbAs5A3wq6ngN0oKF18RuL3Zn7cYby99g00nvJ7wPsrMUSs5ILEJJb3dZh6xfaA5B0GIUT45LgqDLemgHEU3xWOhUG//op4E5bSyUgo+iVLFwEu1YVh4q9k7EC8ND0wCfkyp+vf6w8JsBALrT4af1PzFiaLigIeLT40PyjIgRWGjBi/c4wzcuMZYgvvzyS6ZzixYtmHkNMrHh/LELEC4JYucMiSAyrZ22UG38Sz4FhjwKcEbsZrcXVSxuFXopvxB1hySjev/QNcCnBz9fWPjLp6ikCNNTp6PW7FqoGlUVI3aOwLWi0DRaSLoGg4U/rELp/chNy4wliJQU6cDV2rVrofaxCxwuCWJuW+leaIs7ZdXGv22iRFZXTtlVRbaUq4oFgBvFJXhj3GaU6x6PlBORsXjvDQt/FbPp7Ca8vPRlNmrouLIjTuSe8JeE+/eBYsG9YjoFHL1lubEEIZdPN8m5O7Uw9zhmPXNHEGTaYsD9QMzXZqnsNV/Vxn8mRSIIk++i8CqUTS/UsKDp0W/mSwb4ovectUky64tVw8KXFHQD3JfJXzJieGnxS1h7aq2v6CH1Ti8WIaWcDmF/3xpjDkGo3f1QpUoVHaIZG5U7gji2SuqQjyQZq6iG3FQbf3GhZO4jqYeGHMInihoWY5KPMRtLv60MfQN8empKDQu19AXFBRi7eyyqz6yOGrNqYOLeibhREj4nyklnrVio4RNOYeO3xRlLEHPmzAGtP9x5550uaw9k8rtRo0a2YccdQcR9D/S/F6C7oS12Xhv/xIbA1GYWS2Nvce5YxO2TDPB1mRseBvj0oOuOhXtaGlmtOrGKGdWjU9Dfrv0WmfmZ7tHC4tkfFmGhpAYlJm5PNJYgTpw4wdi3du3aLmsQdHFQcXGxBpHMicIVQdCaw28VgdlvmaOsn1y9Nn4iLZr2onsiIsQ5Y7Hn1BU81j0ercduQkFR5GAgV7UzFnKY/J2Wk4aPkz5m00mtlrXCtnPb5Fdh+e0Li7BU2ItSU1NWGEsQcjlpaWkoKCiQH3H9+nVkZNh3ApUrgsg6JE0v7ZjiwMdKj9fGv2eeJNf5VCvFsbUsGYuzV67j6QEr8ezg1biYF17TJVoBlrFwjp9XmIeh24eiyowqqDO7DmYdnIXim/b90HOWzUy/GhZmlsdr3tN3rjKHIKpXr47CwkKH3uR/+umnHc9We7giiA2/SR0xWVK1wXlt/BePSXLR9tsIcYQFGeBrOmI9KvRKxJHz4WWAT081OrcLMoURfTwa9efXR8XpFdFrUy9kX7futL8euc2I64yFGfmHSp4zdyebQxCVK1f2wKBSpUoeYWoBCQkJ7ORz2bJlMWjQILUomD9/Pp588kmUL18eb7/9tmoc50CuCGJKU2Dcs87iWer32vhp6mvQQ8DyLpbKY2dhq5OT8eG07SjzUxzWHuHLRL3VuMjt4kD2Abwb9y6bTmoT04aLG97swsLqcnkrb86eteYQROPGjREdHe3Qd9myZWjYsKHj2ZunpKQEZcqUAU1R0aiDSOXAgQMu0Y8ePQraESWbEc/K8m9ZkxuCuHYJ6HMnsLq/i05WPsgdgWqZUa1sJS9VmUwM/GRsItuxFLXZvulPE9XTlXXsqlj03dyXjRjqzquLJUeXcG9UT5eCOiL7/B/RkU+oR523d705BHH8+HHUqlULDz30EB588EHUqVMHx44d84sX2W5q0qSJI97AgQNBH2f3/fffY9KkSc5Bfv3cEMS+hdI0zukdfmU2K4LPxk/E1effQGHonoLVitusrScYOfSOjpw1FzVsyKje3ENzUTOqJrvyc/C2wcgtzFWLGjFhPv9HIgYFYOG+jeYQhIxhXl4erl6V5nXPnz8vB3v9XrhwITp06OB4HxUVhU6dOjmeyfPKK6+ASOKZZ55hJERTUmpuwoQJTDlaDylVqhTbXUUVb+fn/O8tUDjgIaxJXm2bHDExMV7L3rfwF0Zgu5b+7jWOnfgZVfaYhatQumssmpX9eYIAACAASURBVA2OAU0zGZVvqOUzOWEyXpz9IptOajmrJWYnzY5YLJzrztf/iHO8cPcPXDTVXILIycnBlClT2BmI//znP2r9uEvYggULPAiic+fOLnHo8qFWrVqhqKgI6enpeOCBB3DlyhWXOO4PXIwgSoqBQf8FlnZ0F8/SZ2rUXl1eljTC2TTaa5RQf3Es6yoq9E7Ei7+tQ/zK5FBXJyD5s65l4cf1PzJiaLSgERIyEpCcHJlYqAHo839ELUGYhi0/uM14gqAtrfPmzUPLli3Z9NIdd9zBfpXcpNvT/DgtU0yffvoppk2b5siJ1ja2b9/ueFbzcEEQJzZJne+BZWoiWhbmt/EPrwAs+MAyeawsiAzwPf8LGeBbidOXr7F2aWX5dpdFRvWm7J+CmrNqMqN6I3eOdBjV89su7BbewvIFFhLYsYd3GEsQbdu2ZaTw4YcfYsWKFaBFZ7obQqujw3R0RSmNDORF6tRU1zlimlJq164dy5Juq6M1juxs31vwuCCIFT2BvncBBfbO7/pt/PPbSQf5tFZaiMQjA3yvj9vEDsPtOikZ4POLRYjopkXMDWc2oMWSFmzU0HlVZ5zKdTXMGElY+MNLYCEhlHBkp7EEQbuOKlasiKFDh+LUKakBUoevx8XFxbFb6Gg304ABA1jSnj17OnZF0ZF/uuuatrlWqFABc+fO9Zs9FwQxpiYw/WW/spodwW/j3zhSGunk83eZfKDYsDYzbzdblI7Zqxjg84tFoAVylO7U1VP4YvUXjBiaL2mO9afXq0oXCVioKq4SKLCQQFlxdLexBEHZHjp0CNShU6f83HPP4e6770Zmpr02W2wniEvpUqe7+XeV5mhtkN/Gn7FRkvVIorWCmVja6NVHGTmMWnXUpRS/WLjEDq2H68XXMXrXaFSLqsaM6k3aNwmFJcrhVXdtwhkLd139PQssJIRWH99rPEE4g79jxw588803bLsrbXW1y9lOEFvHS51u9nG7IHCU67fx38iTzmok/+xIE8oeGjE8/GMsvpq32+N2M79YhKDiNFpKykjCCwtfYKOG79d9j/P5/ncQhiMWgVafwEJCbl16qrkEIVcQNVq6QMguZztBRL0KjKpul/ou5Wpq/GOfAWa2dkkXig+01kAG+F4bu4ldAuSugyYs3BNx/Hz8ynF0SOzAiKF1dGvsyNR+3ibcsAimmgQWEnobTxy0hiCCqSwj0tpKEPSLvN/dQGI3I1QJOg9NjT+6MzD44ZC+gpR2KdFuJdq1lO3FAJ8mLIJG3PwMrhZeBR1wqzyjMurMqYM5h+boNqoXLlgYgbbAQkJxy8nDgiCMaFA+8zgYI00vpasvDvpMa8JLTY0/ZZok86U0EyQwP8u8G8XsnAOdd6BzD96cJiy8JeYgnIzqLT22FGQag4zq9d7UG5cKLgUkWahjEZDSXhIJLCRgtp8+JgjCSxsxLnhZJ2DgQ0BJkXF5BpGTpsafuU8iiL0LgijJnqQlN/9A+1sG+DYc9b0TSxMW9qjht9TUi6loG9eWTSfRNz0H40IZi2D0VksrsJBQSTlz3ByCILMadBaiadOmrCQyuDd58mS1urAkzLYpJjocOLQcsOB9S/TUUoimxk+nvgfcB8T/qCVLruL0WZ7KFqVnbjnhVy5NWPjNxdoINEKgkQKNGOrNq4dlx5YZYlQvFLEwC3mBhYTs7nMZ5hAEEQOZ5JZNfNMBODqzYJezjSDO7JR+ie/xf1bDKmw0N34ySz6psVViGVJO1BbJAF/f5a4WgL1lrhkLbxlYGE4X9cw+OJutMdAFPr9s/wW09mCUCyUsjNLZWz4CCwmZ1POnzCEI+XIgMsstO7U7IuR3Zn/bRhDJA4HedwD5vk96m62/c/6aGz8tqvcrxc3UmLMOan66z4HudaD7HWiaSYvTjIWWzEyMsz1zO16NfpVNJ3VI6gDarWS0CxUsjNZbLT+BhYTKoQunzSGIevXqMfMXVatWZSVt2bIFdevWVasLS8JsI4jxdYHJL1iio9ZCNDf+/Yul0c/Z3Vqzti3e0fNX2Y1wZICPFqi1Os1YaM3Q4HiZ+Zn4fu33jBjoXMOKEys8znIYVSTvWBilp5Z8BBYSSkcvnjOHIHbu3MnMcf/rX/9i3+XKlcPevXu11I0pcWwhiKuZUge7/ldTdAo0U82N//IJSf7t+u7eCFSuQNPRFtbnflnN7pSmu6X1OM1Y6MnUgLh04plOPteYVYOdhB6zewzoZLSZjlcszNTZW94CCwmZtEvnzSEIyp7WHcjQ3v79+5lpbm+VYUW4LQRBdzv3/hdwPrjdJUbjo7nx0xWkv5Sx3Ty5L/0LikrQeqxkgG/PKd8m39Xy0YyFWmKTwtadXodmi5uxUUOX1V1w+uppk0pyzZZHLFwltO5JYCFhffLKBWMJYvHixfD1sa6KXUuyhSDmtgWGP8XdYTNdjX/2mwAZGeTQ0en8LnN3sR1LcfvOBSShLiwCKkF7opO5J9FpVSdGDGR1deOZjdoTGxCTJywMUCeoLAQWEnyncy4ZSxAffPABvH3at28fVKUFk9hygigqAAbcD8R+E4zYpqTV1fjX0g1zd9huolwNiBErJQN8Y5L9X2Wrlp7CdGHhLZMgw68VXQPdy1A1qiq7p2Hq/qmgexusdjxgYbXO3soTWEjInM/LMZYgvAFud7jlBHFspTS9dHSF3ap7lK+r8ct6pK/zyMfOgOg9kgG+b+bvCWrRVhcWBitMI6CE9ATQjW4VpldA1/VdQTe92eXsxMIunb2VK7CQkMm+dtUcgqALfL744gvQLqZq1aqhS5cufi/18VZZRoRbThBx3wH97wWKzF1YDAQbXY3/2qVbC+3DAinKlDQ7T15Gue7xeGPcZlUDfHoK1YWFnoz9xD1y+QjaJ7ZnxPD68texK2uXnxTmv7YLC/M101+CwELC7Mr1fHMIonHjxujXrx+7GY5uh+vfvz+7l1p/VRmTwlKCoMXd3yoAs98yRniDc9Hd+EdWAWg9hQN36hIZ4FuBukOSQdeHBut0YxFkgbmFuRi0bRAzqvfs3Gcx//B8lNwsCTJXY5JbjYUxUpuTi8BCwvXqjevmEASNGtxd9er2mbu2lCCyDkq/undMdYeAi2fdjX/RR8CvT9gu+9WCIjQZvg4VmQG+PEPk0Y1FgKWSUb3FRxc7jOr129wPVwr077oKsHhNyazCQpMwNkcSWEgVcK3ohjkE8e2337KrQG/evAn6kNmNXr162VbtlhLEht8kgshVrra0TXGVgnU3/i3jbNenuOQm2k3ZhrI/xWHjMd8G+FRU9hqkGwuvOXl/se/CPrSJacOmk96NexcHsw96j2zjGyuwsFE9XUULLCS4CouLjSWI22+/Hf/85z9B3//zP/+DP//5z+xDfgq3y1lKEGTDaNxzdqnqt1zdjf/UdokgyGy5Ta53tGSAb862k4ZKoBsLHaVnX89Gz409GTHUn18fy48vD2pBXUfRAUU1E4uABLIxkcBCAp9+3Acy83ObjXUXUNGWEQQt6va5E1g9ICA5rUiku/HTlt2+/wes7G2FeB5lzNicwc46DIjVZoDPIwMfAbqx8JGX/KroZhFmHpiJOrPrgIzq/brjV+QVGjMlJpdhxrcZWJghpxV5CiwUlE0jiMuXL2Pbtm1Yt26d46MUa63PMoKg+xPo9PTpFGsV1FFaQI2fbEpNb6GjFGOirjmchdJdY9Fh+g7NBvj0lBwQFj4K2HZuG1ota8VGDZ+s+ARpOaFz4ZLRWPiAiftXAgulikwhiEmTJjHz3nfeeSfq16+Pv/3tb2jQoIFSqsU+ywhi4YfAkLIA3QPBqQuo8cd8Dfz8gKV6Hc68iqd6JeKlEeuRr8MAnx7YA8JCpYBzeefwzZpvGDG8uOhFrDq5iuvpJBUVuDg0qCaXHWFGtQs7ZDe6TFMIgu5+KCgogGzi+9ChQ3jzzTeNll1zfpYQBF2yM+ghrm0XEWABNf7ds6WR0YXDmjEPJuKFqzfwzKDVqDFgJc7lmHeWJCAsnBS7UXIDE/ZOwNMzn0b1mdUxds9YFBQXOMUIHW+wWISOpv4lFVgoGJlCEPJ9EEQQN27cYKXJZKEUbZ3PEoLI2Ch1ogeWWadYACUF1PiJGGjqjIjCZEcG+Fr9vhGP94jHvtM5ppYWEBYg81p/YM2pNWi6qCkbNXyV/BXO5J0xVVazMw8UC7PlsiN/gYWCuikE0apVK1y5cgW9e/fG888/j5YtW+Kll15SSrXYZwlBJPUA+t7Fpd0iZ7gDavw0ZUZTTDTVZKKjjveLOZIBvoT9gRng0yNeIFhk5GTgs5WfMWJ4eenL2Hx2s54iuY0bCBbcKhOkYAILBUBTCELJHli7di2io6NRWBj8yVfnfPX4LSGI0TWAGS31iGVL3IAbPy1S02K1iW74iiNsx9LvawI3wKdHPD1YkFG94SnDUSWqCmrNroXpqdNBO5bCxenBIlx09qaHwEJBxlCCyM3NZTlfunQJah+lWGt9phPEpXRpCmbLWGsVC6C0gBs/bXOl7a607dUEt2z3GUYO3y0IzgCfHtG0YEGjmri0ODRc0JCNGrpt6IaL1407rKdHXjPjasHCzPJ5yltgodSGoQTRvHlzlvMjjzyC0qVLw/1bKdZan+kEsXW8RBCX+N/WGHDjp4NytA5BB+cMdiknLqFct3i8OX4zCout2wHmD4vDlw7j/YT3GTG8sfwN7M7i//rVQKvGHxaB5huK6QQWSq0ZShCULf3iOnnS2BOviriB+UwniKhWwOinAxPO4lQBN/7cc7dGSeMMlZgM8FXrtwL1h67BZQMM8OkRzhsWOTdyMGDLAFSaUQnPzX0OC44s4Maonh799MT1hoWePMIlrsBCqUnDCYKyVjPWpxRpvc9UgrhxFeh3N5DU3XrFAigxqMZPRvsWdQigVPUkuQVFaDxsLSr1SULaBetPG7tjQZZVFx5ZyEiByIFIgsgiEpw7FpGgszcdBRYKMqYQxOeff47t2wObikhISAB16GXLlsWgQYMUSd18CxcuxG233YYdO3a4vfF8NJUgDi6Xflmnr/csmMOQoBo/mf0m898GODLA9+7krcwA36bj9szpO2Ox58IevBnzJptOahffDjS9FEnOGYtI0ltNV4GFgoopBPHkk08yI31lypRBxYoV2alq+vbnSkpKQGnS0tLYrqdKlSrhwAFPGzxXr15l22dr1aplP0Es+xwY+BBgwzWR/vBUex9U418/TCJDsjkVhKNpyB5L97NF6Xnb7ZuOJCxowZkWnulWt4bzGyI2LTbkTkEHURWOpEG1C0cu4eERWCj1aApBnDhxAmofpVh13+bNm9GkSRPHy4EDB4I+7u7LL79ETEwM6tWrZy9B0PmAIY8CCz5wF5Hb56AaP109SgvVdBVpEG7qxnRGDgPj7DN9TVtUe0b3ZFtWaesqbWHNL8oPQqvQThpUuwht1T2kF1gokJhCEHL2WVlZbMGaFq21LFzTtFGHDsocd1RUFDp16iRnx7537dqF1q1bM7/tBHEmReow98xzkZHnh6Aaf0Eu0PsOYO0vAauYfEgywPfxjB24efOPgPMJJiEdbmu5tCUbNdChNzr8FukuqHYRZuAJLJQKNYUg6GDco48+ir///e9sqyvdB1G+fHmlVC++BQsWeBBE586dHbHJPjmRQkaG9A/tiyAmTJjAbJmTgqVKlWI2iKjijfxkTP0Ef/S+ExuTog3N10gZ3fOikZd7mJ7n/F+eQvbIhgHlEbV8NR7vFou6P8cjcWVyQHnokdU97uKVi/HugncZMdSfVR9DFg9BcrL1crjLxcNzsO2CBx2MkkFgofSTphAErR1kZ2ejShVpQZP+CT/++GNHR+/N42+KKScnB3fddRcefvhh9vnrX/+K+++/3+80k2mL1HSyeLIyJeZNL57C6Z8oKLe0I/BLGdrPrCubrKsFzABfzZ9XIjPHnMN23gQiA3pkSI+M6tFn/J7xIEN7QWPhrcAQDBdYKJUmsFCwMIUg5EyJKOhXP7kaNWoopXrxFRcXswN26enpjkXq1NRUL7Fh7xqEfC6AFm5DyAXd+LdPkqbVLp/QrDUZ4HtlzEY80SMB+89Yt22UFsPJ9DaZ4KZFaDLJTaa5ZRc0FnJGYfAtsFAqUWChYCH35UqIf5/fG+UaNWqEvLw80PRQmzZt0KVLF9SpU8d/zgDi4uJQrlw5tptpwADpZraePXsye07uGfiaYnKOa8oIImW61FGe99xl5Vw2b/6gG//Z3ZLe+xdrUo3WGT6fvROPdI1FYmqmpjRGRErPSQdd2kPEQJf4bD231SPboLHwyDF0AwQWSt0JLBQsTCGI/Px80JZVGhFMnz4dI0eOZFNOSrHW+kwhiDlvA8Of0j3VYq3mnqUF3fhpO2+/UkBiN8/MVUKGJR1mO5bGrz2u8tb4INqJNGzHMGZUr/bs2uz6T29G9YLGwnjxbctRYKFAL7BQsDCUIGjH0aZNm5TcOfEZThBksG7AfUDsN5xoqF0MQxr/pMbAlBf9Frpk12lGDj8s3Gv62QKaTlp+fDkazG/ARg09Nvbwa1TPECz8ohAaEQQWSj0JLBQsDCWIESNGoHbt2mwB+YcffsDu3XwYNzOcII6ulKZZjq5QkAwRnyGNP/5HoP+9AN2i58Vtz5AM8LWZsMV0A3wHsw/ivfj3GDG0iWmDvRf2epHKNdgQLFyzDNkngYVSdQILBQtDCULOlg7JDR48mO1ieuKJJ9C3b18cOXJEfm35t+EEEfutNIIwyfS1mQAZ0vj3LpAIMnOfqqgns6+har8VaDB0Da5cM+8ekCsFV9B/S39mVO/5uc9j8dHFuPmHdmuwhmChikDoBQoslDoTWChYmEIQSvYAHWyj7a5/+tOfnIMt9RtKELS987cKwJw2lupgVGGGNH4ya04nqlOmeYiVc70IDX9dg8p9k5B+0ZyTyWRUb/7h+Xh27rOoPKMyBm4dGJBRPUOw8EAgNAMEFkq9CSwULEwhiKKiIixfvhxt27bFvffeizfffBNLly5VSrXYZyhBZB302jlarFZAxRnS+IkkBz8MRCuHGEmYolsG+B7tFoctadkByecv0a6sXaC7GWh30gcJH+DI5cBHpoZg4U/gEHkvsFAqSmChYGEoQaxYsQLt27fHPffcgxYtWmDWrFmgHU12O0MJYsNwiSByz9qtVkDlG9b4Z7YGfle2LtMicbcl+9ii9PwdpwKSzVeiC9cuoOv6rowYGi1ohIT0hKAXvg3DwpfgIfJOYKFUlMBCwcJQgqhfvz4mTpzIrhtVirDfZyhB0O6d8c/br1SAEhjW+JN/BvrcCdyQ7nGYvEEywDco/lCAkqknKyopwtT9U1FzVk1UjaqKkTtHgu6HNsIZhoURwtich8BCqQCBhYKFoQShZMuXzzCCIDPX1ClS5xiizrDGfyRRGkllbMSqg+fZQbhPo1IMNcC36cwmtFjSgo0aPl/1OU7mGmsa3DAsQrQtOIstsFDQEFgoWAiCULDw79s7X+oUT6f4j8tpDMMaf/5FhsX5+F/wZM8EtBi1AdcLSwzR+vTV0+iyugsjhmaLm2Hd6XWG5OueiWFYuGccgs8CC6XSBBYKFoIgFCz8+xa2B4aUBW7Zl/KfgL8YRjb+kuEVsKpvU9QeuArnc4M3wHe9+DrG7B6D6jOro8asGpi0bxIKS8zbJmskFvzVtD6JBBYKXgILBQtBEAoWvn10KGzQQ8DSz33H4/ytUY2fRgvrf26Bs73KIPVscAb4aIF75YmVeGHhC2zU8N3a75CZb77dJqOw4LzKNYknsFBgElgoWAiCULDw7cvYKE0vHYj2HY/zt0Y0fjLA13FWCvp37yhhcvV8wFqnXUnDR0kfMWJ4NfpVbM8M7C7zQAQwAotAyuUxjcBCqRWBhYKFIAgFC9++pB5A37uAG1d9x+P8rRGNf0jiIbadNTp6kUQQh+N1a51XmIch24egyowqqDOnDmYdnIXim95Nd+guQEMCI7DQUExIRBFYKNUksFCwEAShYOHbN7oGMOMV33FC4G2wjX9RimSAr+vivfijMB/o829gdX9dmpNRvXrz6qHi9Irovak3LhVc0pXeqMjBYmGUHDzkI7BQakFgoWAhCELBwrtPNi2xZZz3OCHyJpjGvy39EuiUdNtJW9ipaabyuGeBqFaataeTz3QKmozq7b+4X3M6MyIGg4UZ8tiZp8BCQV9goWAhCELBwruPiIFsDxFRhLgLtPFnXMxHlb5JaPDrGuRcK1JQWN5FWrzXuLNr89nNjCBSztu/VThQLBTlw8cnsFDqUmChYCEIQsHCu4+mlkY/7f19CL0JpPETIRAxkAE+IgoXt3OGRJ4Xj7kEe3tYe2otI4h9F9QtwXpLZ0Z4IFiYIQcPeQoslFoQWChYCIJQsFD30aI0LU4ndVd/H2Khehs/GeB7e+IWNrW0Vc0A3/lUiSD2zNOExIoTKxhBHL50WFN8MyPpxcJMWezOW2Ch1IDAQsFCEISChbqPtrXS9FLGBvX3IRaqp/HT+YSuiyUDfLQ4repulgAD7gfivld97R4YmxbLCILujLbb6cHCblnNLl9goSAssFCwEAShYKHuW/a5NMdOdzGHgdPT+CetT2PbWWlbq083tRkwsaHPKPLLJUeXMII4k3dGDrLtWw8WtglpUcECCwVogYWChSAIBQtPHy28DnkUIBMbYeK0Nv4VByQDfHQgjg7G+XR0RqTf3UDxDZ/R6CVd9EO7mMh8t91OKxZ2y2lF+QILBWWBhYKFIAgFC0/fmRRpeomM9IWJ09L4yXQGGeBrOVqjAb7UpRJOhJcfF3UgihFEzo3gzHP4KUbTay1YaMooDCLxhAVdOJaeno6DBw/a8qFbMO0q265yCW/C3d0JgnBHxPlZvvOAzHyHifPXEZDRvVo/r0KdgauQpdUA35VTEkFsm+gXpcn7JjOCIMN8djt/WNgtn5Xl84QFdVYXL14M+kKoQPG7ejW0rSXo1ZvWGglvwt3dCYJwR8T5mS4GoguCwsj56gjIAB+Z7S7fMwEHzuZq15quIB1aDljyqd80Y/eMZQRB90rb7XxhYbdsVpfPExb0K5o6LbtcpBEE4Ux4E+7uThCEOyLyM10pSruX1g+TQ8Li21tHQOsMdOFP6a6x7AIg3crOaaPprAjdCFd5RmXd2ZuRwBsWZpTFe548YaHWUVmJXyQSBOGrhrsgCG8tL2WaRBDnD3iLEZLh3jqCwQmSAT66OjQgt26IhFeB77WFoduHsrseAirD4ETesDC4mJDIjics1DoqK0GUCWLAgAEoX748KlasiMqVK2Pr1q14+OGH2XSMuzx16ij3s7u/C5VnNdwFQXirPfpFPLwCjb28xQjJcLWOYP6OU2w7609L9gU+tD++WiKI48k+cRmwZQCenfuszzhWvVTDwqqyeSuHJyzUOior8SKC2Lx5M2rXro0bN6SdeTRHf/bsWa8EYaV8ZpWlhrsgCDW0iwqAAfcBsd+qvQ3pMPeOYEtaNjsl/e7krYoBvkA0vH5FIoh1Q32mJuutDeY38BnHqpfuWFhVLo/l8ISFWkdlJWZEEIsXL0aLFi08ipVHENevX8eLL76IiROljRn/+Mc/POKGWoAa7oIg1Grx6Eqps6PvMHPOHUH6xXxmX6nRsLXIue65xU236qOqA3Pe9pnsp/U/4cVFfCz8O2PhU+gIeMkTFs4dVZ/lqXhz/GZDP5SnL0cEkZeXx6aVypUrh44dO2Lt2rUsCRFERkYGGjVqhBkzZjiyEQThgAK3Kd7Q8D322GP6BKWRA40gaCQRZk7uCK5cK0SDoWuYhdaT2deM0XLxJ9JuJh/Tct+u/RYtlnj+MjNGAH25yFjoSxWesXnCggeCoFouKSkB4dKrVy/ce++9mDZtGptiqlSpEmbNmuXSEARBKHCEN0FQ50ZrD35+CStwhJaPGnxh8U20mbAF5brFY3uGgWc8tk6QRl453s1odF7dGa9Fv8YFaDx1inYDwhMWzgRhBy7yIrVz2QsXLmRTTjSCoBHFO++847JeJwhCQctUgkhISAD94i9btiwGDRqklHrLN2zYMDz55JNsZ0HDhg1x4sQJjzjuAbpGELRriba3pkx3zyYsnpOTk/HDwr1sUXrJLi8G+ALV9PStk+cHlnnN4dMVn+LtWN/TUF4TG/yCp07RYNV0Z8cTFjwQxOHDh3H06FEHjt27d0enTp0ci9RdunTBZ5995ngvCMIBhXlTTDSkK1OmDNLS0lBYWAgayh044LrNlDq4a9ekKZGxY8fizTffVCTz4tNFEHTugQgi95yX3EI7+PupSYwcfk0ywdw22WIim0wrenoFqX1ie7SLb+f1vZUveOoUrdRbrSyesOCBIFJSUkBbV+Ufo6+++irb3iovUtPBsg8++ADffy9ZMRYEobQq00YQtLWsSZMmjpIGDhwI+nhzZDPlmWee8fbaEa6LICY3AegEdRi6xNRMPPJjLD6fvdO/Ab5A9Z/YAJjW3Gvqd+LewUdJH3l9b+ULnjpFK/VWK4snLHggCDWMwj1MDXeudjHRPF+HDh0c9RAVFcWGdY4ANw8N+fr37+8WKj1OmDABpBx9SpUqxRab6J/A12djUjT+6H0nMqZ+7DOerzx4fTdt2SqU6xaLuv1jkLQq2TT9Tk98G8X97sGa5FWqZbw05yW0md9G9Z3V2MXExHAhh9V6q5XHExb0w4/WAez6XLlyxbay7dKZyiXc3dsGVwSxYMECD4Lo3LmzKgHMnDkTtWrVchxkUY10K1DzCIJuRaPpJQ1WSX2Vx9u7zJwC1Px5JZ4ZtBpLE1ebK96euRKGWZ52XajgV5a+gq/XfG2uDBpzp38G4SQEeMJC7ZeslfVEnWUkOjXcuSIIrVNMK1euxBNPPIGsrCxN9aiZIOjeB7r/ge6BCBN3rbAYzUauZwb4Dp7LZb8QTFXt4lGJIHZGqRbz0uKX8MO6ccx9PwAAGMFJREFUH1TfWR3IU6dote7u5fGEhVpH5S6vmc+CIBR0uSKI4uJilC5dmpmdlRepU1NdD7XQMIgWsp13GCjqqPs0EQTdGDfoIYBukAsTRwb4Pp6xgxngSz4kkanpHQGR68CHgOVfqqLYaEEj9NjYQ/Wd1YGmY2G1QkGUxxMWgiCCqMggkqrhzhVBkG5xcXGg04tEAmQsi1zPnj0RHR3N/HSC8Z577mGnHMmA1ssvv8zCff3RRBB05zRNLx1c7iurkHo3MP4g27E0daNigM+SjmDGK8C451SxqjuvLvpvUV83Uk1gYqAlWJgov5FZ84SFWkdlpK7+8hIjCAUh7ghCEc04nyaCSOoubdG8ER7zj/O2n2Tk0GPpfpcDPZZ0BKv6AX3+DRR5XgpUa3YtDN422LjKDSInS7AIQj4rk/KEhSAIK2teKUsNd0EQMj6jnwaiWslPIf296fhFlP0pDmSAr7jEdT3Fko7gUJw0Gju51QPHqlFVMTxluEe4HQGWYGGHYgGUyRMWah1VACoFnCQ3NxfPPvss4uPjHXnMnz+fGedzBIShRw13QRBU0dnHpQ5ty7iQr/a0C3mo1CcJjYetRW6BpwE+SzqCq5kSnpvHuOBJh4sqTK+AMbtdw10iWfhgCRYW6hNMUTxhodZRBaOb3rQ0xbR//362EaagoAD5+fl49NFHcfz4cb1ZhVR8NdwFQVAVbhkrdWiX0kKqQt2FvZxfiHpDklGt3wqcuqRugM+yjmBYeYB2hTm5wpJCRhCT9k1yCrXPaxkW9qmouWSesFDrqDQrYkBEeQ2CTkn36dOHnZbu168fy/mXX37BU089xT6jRo1ylEYG/R5//HE0btyYWXf47bff2Ltx48bh6aefZlYhXn/9dZCZcF6dGu6CIKi2ZrQERtfgtd40yUUG+Mgscrnu8Ug54d0An2Udwfz3gBGVXGTPK8xjBDE9lQ87V5Zh4YICnw88YeHSUcX/CExtZuyH8vThZIKgkQOtX1aoUIGdt9q2bRvr6MnUD8WhrfZ79+7Fli1bUK1aNRaHpqdoJ6ZMENnZ2Y6SfvzxR5B5IF6dC+63hBQEQYvSfe8CkvjYehlI46Gpm+8W7GGL0st2e7ekSnlb1hFsHCGNyvKVf5Ds69mMIOYcmhOImoansQwLwyU3PkOesHDpqGwkCEKZdlDSqIHcr7/+ir59+zrA79q1K37//XcMHToU8giDXn7xxRcOgiDbcc899xwjGbLjRNYfeHUuuN8SUhDEgWipI8vYyGu9+ZVr7JrjjByGrTjiN65lHYG8bfjoCodMmfmZjCAWHVnkCLPTYxkWdiqpsWyesFDrqDSqYUg0eQRBmfXu3ZsRAPmJCNQIYsiQIV4J4sEHH2TrGZR+0qRJLpYiDBHWwEzUcBcEsfRz6YBcSbGBUFuXVcL+c4wcOs/Z5bKd1ZsElnUEN/KAPncCyYqxxZO5JxlBLD/Ox1kTy7DwVhkchfOEhVpHZSVU3giCppiqVKnC1hHoxjmy9Lpv3z52fzWtM9D91ZSWriqQp5j+/e9/MyuwRUVFaNCggSAIKytSa1lez0HQqd8hZYGFH2rNiqt4e09fweM94tHq940oKCrRJJulHcHvtYGZyuVAxy4fYwSRmJGoSVazI1mKhdnKBJk/T1jwShAEsbdF6h49erD1CrJG3aZNG0ydOpXVyOjRo9maRL169dj0krMx0iCrzPDkarhH9ghCvuBm7wLDwTY7w3M511FjgGSA78LVG5qLs7QjWNYJGPwIcOsK0tTsVEYQySeTNctrZkRLsTBTEQPy5gkLtY7KABU1Z+E8gtCaiEYU5Ghhm0YZtHgdak4N98gmiNUDpGmQa953/fBYyfk3ivHSiPV4qlciDmfqO/ltaUewY+qt7cOSqY/dWbsZQWw8w8d6j6VY8NiQnGTiCQu1jspJVNO9gRAEXVxGpn9oq6u8qG26oAYXoIZ7ZBME2Qua8qLBMJubXcnNP9BhumSAb81hbdZsnSWytCM4t1ciiH0LmQjbzm1jBLE9c7uzSLb5LcXCNi21FcwTFmodlTYtjIkVCEEYU7K9uajhHrkEkXtW6rw28GH2QWvTGBB7gC1KT9+UoTWJSzxLOwKykNv/XiChK5Nhw5kNjCD2XNjjIpNdD5ZiYZeSGsvlCQu1jkqjGoZEEwShwBi5BJEyTSIILxfbKBDx45uzTTLA12vZ/oCFsrwjoCtcJ7/A5F19cjUjiIPZ6pcJBaxUgAktxyJAOa1IxhMWgiCsqHHPMtRwj1yCmNMG+K2CYwHVEy6+QjYekwzwvT91m4cBPj2SWt4RJHYD+t8DlBQhIT2BEcTxK3zYtLEcCz0VZXFcnrBQ66ishEOMIBS0I5MgyAz1gPuAuO8UJDj2HcvKQ8XeiXhh+FpcVTHAp0d0yzuC/Yukkdq5PYg+Hs0I4lTuKT0imxbXcixM0yT4jHnCQhBE8PUZSA5quEcmQdDpXroc6NjKQHC0NM2l/ELUHZKM6v29G+DTI5DlHcHlDAnrHVOw8MhCRhDn88/rEdm0uJZjYZomwWfMExZqHVXwGmrPgUYQf/rTn9iuJDLMR0b2yP4SuX/84x/aMwqxmGq4RyZBxH4DDLgfKCrgugpvFJfgjXGyAb7LhshqeUdAZyB+KQ0s/RyzD85mBHG5wBhdggXEciyCFdjE9DxhodZRmai6R9ZEEM5E0LZtWwwbNozFcw73SBjiAWq4Rx5BUIc1/ClgzttcVycZ4Pt6/m62Yyl6z1nDZLWlI5j1OjCmFqbtn8YIIr8o3zB9gsnIFiyCEdjEtDxhodZRmai6R9buBEEmuzt27MjiyQRBB+MaNmyIqlWrMkN8y5YtY+/pRPWIESMceXbr1g0jR450PMseMu4nmwenk9dk54ncxIkTHebBW7du7Ri5vP/++/jss89Qv359djJ77dq1aN++PbMoS+9kl5SUhNq1azO5aOQjH+AjS7JkGqRixYr49ttv5egu32q4Rx5BnE+VpjxS+DA57VJDTg9jko8xchix8qhTaPBeWzqCNYOB3ndgws5RjCCKaPsrB84WLDjQW00EnrBw7qjoetoPEj4w9OPvyltngiguLkbLli0dZrplgqBwMu1N7uLFi8z+Ev2oy8jIYJ0zhd+8eRNlypSBs8lvCt+xYwebvqK7IagsuoxIJgjnuN27d4d85wSRwFtvvcXsrREZ/fOf/2R2oKgMMjW+e/duJsfzzz/PTnNTOYMHD2bGBS9dusTMgJB85K5cucK+3f844y6/izyCWP+rRBC552QMuPuO2ycZ4OsyV5sBPj0K2NIRHF3JMB+d/D0qTq+oyaigHp0CjWsLFoEKa3I6nrBw7qjsIgh5DYJOR3fu3BmFhYWsBmSCION7ZLqbfpFTnL/97W/IzMxkcejSoF27diEhIQGvvabYIpOrkAz50QVDsvv6668dBEEjA9k8+COPPIJPP/2URSOCmDVrFvOnpaUxUpHTv/fee1i6dCliYmJw1113MXlIJhoxfPjhhyAyq1SpEvMvXrzYoYucXv52xl0OizyCoH354+vK+nP3vefUFTzWPR6tx27SbIBPjxK2dARkyqT3vzBs2duoPrO6HnFNjWsLFqZqFHjmPGGh1lEFrpn+lM4jCPfUMkFMmzaN3RxHREGO7nqg0QO5efPmoUuXLux9XFwcC3P+M3z4cK8EQaSwZ490kJTKkKeP6HvhQskiAZVDi+eyk98tX76cGQqUw52/ydIsyUJkQlZl1Zwa7pFFEHR5jZsJajWg7Ao7c+U6nh6wEs8OXo2LedoN8OmR17aOYERlDJ5ZH3Vm19EjrqlxbcPCVK0Cy5wnLNQ6qsC0CiyVFoKgdQYaWZCjS4Fuu+02B0HQaIMsSNPNciUlnlaWt2/fzqah6L5rWiOguPIUE40AsrKyQMRDIxE9BHHhwgU89NBDOHbsGJOLdl4dOXKElUF5kqPpJjJBrubUcI8sgtgzT5peOrNTDR9bw/JuFOPF39ahQq9EHD2vzwCfHsFt6wgWfoi+48uj7jx+Rm+2YaGnwiyKyxMWah2VRTCwYrQQBK070GIwdaBkwpuuH5VHEJQJTQ3RwrA3RxcRETG88MILoF1StDhNjq4kpVEEmQcnAtJDEJR+9erVbJGbpr7oEx0djXPnzqFGjRrsma5PnT5dff1VDffIIogFHwBDy9Hqkbd6syWcDPB9OG07yvwUh3VHLpgqg20dwZax6D76ETSerz68NVVpL5nbhoUXeewM5gkLtY7KSmyIIIJxtHBMawBHj3rfYCLvLqJf+dQJ79xp/49WNdwjhyBo58zAhwC6o4Az1y9GMsAXteWE6ZLZ1hGc2obvx5RG83n1TddRawG2YaFVQAvj8YSFWkdlIRRsZ1Gg5R04cIBNLX3zzTc+s3j77bcZidBW14EDlVsXfSYy+aUa7pFDEOnrpemlg3xcdynX9aytJ9h21t7RqXKQqd+2dQRF1/HV72XRatYzpuqnJ3PbsNAjpEVxecJCraOyCAZWTLAjCCtlNbIsNdwjhyDIaFy/u4EbwQ0fjayQ9UcvsGmlD6ZuA00zWeHs7Ag6TqmCN6dXs0JNTWXYiYUmAS2MxBMWah2VhVAENYKwUk6jy1LDPXIIYlR1IKqV0ZgGnN+xrKuo0DuRLUzTArVVzs6OoMPsunh34hPcrAHZiYVV9a21HJ6woI5KPtSlVX4j40XiCILwjliCeOLR0tL00tbxRrajgPPKzruB535Zjer9V4K2tlrp7OwI2i1oig7jHgUuHLFSZa9l2YmFV6FsesETFunp6exUsF0kEWkEQTjTrizC3d1FxAiiQul7JYK45AmAOyBmP5MBvtfHbWKH4XadtN5onZ0dQZulr+CzsWWB3XPMhllT/nZioUlACyPxhAWdAaDOin7R2vGhU9B2lGtnmYS3fOjPudlxRxB0PJ32B5ctWxaDBg1ylpX56UQgXRBO72vWrOmy99gj8q2Ayg/dDoyp6e21ZeHE1F/Nkwzwxew1zgCfHgXs7AhaR7dGl3GPAbHqxsL06GFEXDuxMEJ+I/MQWChoCiwULLgiCDp1SMatyNYInUYk+yG0bczZ/f777w77JHPnzmVk4fxezV/9/j8DK3qqvbI0bNSqo2zHEn3b5exs/C2WtMB302oCE+rZpb5LuXZi4SIIBw8CC6USBBYKFlwRxObNm9GkSROHdLQ/2H2PML2neOTICBUdTfc3V1n9/j8BJzY58rXDQyOGh3+MxdfzdvuV10z57Gz8TRY2Qbf5zYC+d3FxF4edWJhZx4HkLbBQUBNYKFhwRRBkjIqOrcsuKiqKWUyUn+mbjFSdPn3aEUQjDlpg8eX+/vDfUGFqNTw1tbp9nynVUHFaddScVdPWT/UZ9slQYXoF9I37UFoPoitff/6PrZ/ifvfYWr7d+juXL7BQ2qLAQsGCK4JYsGCBB0HIBrFkAihfvrwHQTjbUJfjTZgwgR1hJwX/+te/Ovz0HMkfsjoZyfo76y6wUP4XBBYCC+f/Ddl/++23y12q5u/bNMfUGdG0Kabq/JiY1gmJ4dGp4oWTEBBYKC1BYCGwUBBQfIG0C9MIgtYUyEQubbmSF6lTU11NUIwZM8ZlkfqNN95QtPHiC0RJL1mFfLDAQqlCgYXAQkFA8Yl2ERwWphEEiUWXWpQrV47tZhowYACTtGfPnsxsLT2QDXW6a5W2uZIJW9rx5M+JClcQElgILBQEFJ9oFwILBQHFF0i7MJUgFNGM89F6hHASAgILpSUILAQWCgKKT7SL4LAIOYJQ1BU+gYBAQCAgEDATAUEQZqIr8hYICAQEAiGMQEgRhD/THSFcD7pEP3XqFOrXr8+uRqStwnSnbiQ7OrVfpUoVNG/ePJJhYLpfuXIFr732GujyGro6Uz6IGmnADB8+HPS/QWet2rRpw9Y7IwmD9u3bo1SpUkx/WW+6w5ruxn700UfZ9+XL/u3HhQxBaDHdIQMR7t90L618rSFZq6SNAO5mTMIdA2f9hg0bBrrVSxAE0K5dO0yaNInBQ7sHiTAizZ05c4bdBX39umRdmXZHTps2LaJgWLduHesjiCBl9/333zts4pFtvB9++EF+5fU7ZAhCy7kKr1qG+YuWLVtixYoVYa6lunp0Er9hw4bsgvdIJ4jc3FzWMfozV6OOZPiEEkE8+OCDoF/MtN2e2kVSUlL4KKhRk4yMDJcRBBlOpR+X5Oibnv25kCEILaY7/Ckbju+pETz00EOgziESHU2npKSkgGzuRDpB7N69m20Xf//999mUG5m6yc/Pj8RmwaZd//GPf+Duu+9G27ZtIxIDd4K44447XHC48847XZ7VHkKGILSY7lBTMJzD8vLyUK1aNSxevDic1fSqW0xMDDp27MjeC4IAduzYgT//+c/YunUrw6RLly7o0aOHV/zC9QXNrTdo0AAXLlxg9yK88sormDlzZriq61WviCIIMcXk2g7oQhCyhkvz75HqunbtigceeABke+jee+/F//7v/+Kdd96JVDiQmZnJsJABWL9+PZo1ayY/Rsw3/Zj88MMPHfrOmDHD8UPCERgBHneCCOspJi2mOyKgzpmKNMf83nvv4csvv4wUlf3qKUYQEkTPPfccDh8+zB569+6N7777zi924RaBRlC0g+natWvMHD8t3I8aNSrc1PSrjztBUFuQL26jb1q09udCZoqJFFEz3eFPwXB8v2HDBtx2222oWLEiKleuzD6ETSQ7QRBS7dM6BJlUoLZBUytatjKGY7vp1asX2+pLu3jeffdd0O2VkeRoa+99992Hv/zlL2yUPXnyZJClbNrQQdtc6ZsW8f25kCIIf8qI9wIBgYBAQCBgHAKCIIzDUuQkEBAICATCCgFBEGFVnUIZgYBAQCBgHAKCIIzDUuQkEBAICATCCgFBEGFVnUIZgYBAQCBgHAKCIIzDUuQkEBAICATCCgFBEGFVneGrDG3r/eabbxwKDh06FLTP3whHpinIlIvZjg5wkYVVssTr7MQWXWc0hJ8nBARB8FQbQhavCPz1r39lhuguXrzI4vBCEGRlWKt78cUXkZyc7BHdLIKgw6XCCQSCQUAQRDDoibSWIUCG1wYOHIhu3bqxMp0Jwn0EQHHJUcdbt25dkLlnMon+448/YtasWcygXYUKFXD8+HEWj9J/+umnoFPIFI9sPJGjzp9Onz799NPs4Nn48eNZOOVLowAyMf7kk0+yMOc/c+bMAeVPh7Rkk8p9+/YFyUXmDtxPN1N+9erVc9zjQMblZIusq1atYob3KD+y8S8f+CLzIjJZkg0mSk+ORlUff/wxXnjhBSZfamoq05cOVNLhuaNHjzqLKvwCAZ8ICILwCY94yQsC1LmSxVrqGHNycqCVIMiCJZk2po71P//5D+iELTm6ZEk2VUIEQb/ub968yTpQsu9UUFAAus+4f//+LD6lpxPK6enpjHj+/ve/M787PmfPnmXWdclQHP2CJ6NxS5cuZdGoE6fO3N0RQfzrX/8CmS4nGWrXrg06LU8ykNnqI0eOsCRkXuW3335jfl8EQQYc5bsQOnfuzEiREtH9EHK4uwziWSCghoAgCDVURBh3CMijgp49e6Jfv36aCYJu0JLd888/j40bN7LH1atXM1MU9EAEMWXKFDkaKB6ZrCBT4jSikM2ZPPLII+xeAXkE4Ujg5Fm2bBmzkyUHkYmDr7/+mj36IghnOT/77DNmfXTPnj1MFjkvGk28+uqr7NEXQfTp00dOgtmzZzO7RIMHDxajBwcqwqMVAUEQWpES8WxFQCYIsh9DnSN1gvIiNd17MH/+fCYfTc38v//3/5ifOnLnOyKcO2jnd0QQU6dOdehHBEGdc+vWrZGYmOgIlz3OaeUw+ZtGC/RLX3ZaCcJZzk6dOrEb0IikSBbZORNE2bJlkZWVxV7RaMN5iolGV86OptJGjhyJ0qVLs4uVnN8Jv0DAFwKCIHyhI95xg4BMECQQWaGkS5JkgqBpIHmunzpo2vFEzr0j90UQL730Epveoc7UeYqJDN6RaXVyNNVDF/C458te3vpD01n//e9/2foArWE0atQINKog51y+cxr3/GSCoCkm0vPYsWMsOhGZfP845RsfH8/Cv/rqK68EkZaW5ljPoCk1eYrKuXzhFwh4Q0AQhDdkRDhXCDgTxPnz59ndDzJB0HOtWrXYYizdESHHde94nTto53fU8VIn675ITesBP/30k2PBmRamaf3DOa0aSDStIy9SO5tUdi7fOZ17fjJBUBxvi9R01wNNf5HM3377rVeCoIV9Mn1N02S0zqLFgqezbMIf2QgIgojs+hfaCwQEAgIBrwgIgvAKjXghEBAICAQiGwFBEJFd/0J7gYBAQCDgFQFBEF6hES8EAgIBgUBkIyAIIrLrX2gvEBAICAS8IiAIwis04oVAQCAgEIhsBARBRHb9C+0FAgIBgYBXBARBeIVGvBAICAQEApGNgCCIyK5/ob1AQCAgEPCKwP8HBKbYVI4E2KAAAAAASUVORK5CYII="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(TO DO) Q3 - 4 points**  \n",
    "\n",
    "Maintenant que nous avons défini les variables linguistiques *Day* et *Busy*, vous définirez la variable linguistique *Activity*. défini par activity_lv. Cette variable contient trois sous-ensembles flous : Yoga, Ski et Jeux. Les valeurs de cette variable sont toutes des nombres réels dans l'interval [0, 10].   \n",
    "\n",
    "Ci-dessous est un graph (*Image 3*) de ce à quoi la variable doit ressembler après l’exécution de la cellule ci-dessous. Vous devez définir les fonctions du sous-ensemble flou *Ski* et le sous-ensemble flou *Play games* pour parvenir au graphe ci-dessous.\n",
    "\n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 10)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Instantiate the Activity linguistic variable\n",
    "# Define the Activity linguistic variable\n",
    "activity_values = [(0,10)]\n",
    "activity_lv = LinguisticVariable(\"Activity\" , activity_values)\n",
    "activity_functions = []\n",
    "\n",
    "# TODO: Define the function and add the fuzzy set\n",
    "# Define functions for the Ski fuzzy set\n",
    "# For (0, 10)\n",
    "activity_functions = [lambda x: 0 if 0<=x<=1 else ((x-1)/5 if 1<=x<=6 else 1 )]\n",
    "# Setup the ski fuzzy element\n",
    "activity_lv.add_fuzzy_subset(\"Ski\", activity_functions)\n",
    "\n",
    "# Define functions for the Yoga fuzzy set\n",
    "# For (0, 10)\n",
    "activity_functions = [lambda x: x/1.75 if 0<=x<=1.75 else ((-x+3)/1.25 if 1.75<=x<=3 else 0)]\n",
    "# Setup the yoga fuzzy element\n",
    "activity_lv.add_fuzzy_subset(\"Yoga\", activity_functions)\n",
    "\n",
    "# TODO: Define the function and add the fuzzy set\n",
    "# Define functions for the Play games fuzzy set\n",
    "# For (0, 10)\n",
    "activity_functions = [lambda x: x/10 if 3<=x<=7 else (0 if 0<=x<=3 else 1) ]\n",
    "# Setup the Play games fuzzy element\n",
    "activity_lv.add_fuzzy_subset(\"Play games\", activity_functions)\n",
    "\n",
    "# Show an example output\n",
    "print(activity_lv.fuzzy_subsets[0].values.value_names[0])\n",
    "activity_lv.fuzzy_subsets[1].values.functions[0](2)\n",
    "\n",
    "# Plot the graph\n",
    "activity_lv.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Nous allons maintenant tracer tous les graphiques à nouveau pour voir les variables linguistiques."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot everything with matplot\n",
    "day_lv.plot()\n",
    "busy_lv.plot()\n",
    "activity_lv.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3. Définition des règles floues if-then.**  \n",
    "\n",
    "Maintenant que les variables linguistiques ont été définies, les règles floues if-then (qui seront simplement appelées règles) peuvent être définies pour être utilisées lors du raisonnement. Ces règles peuvent être définies avec les opérateurs flous *NOT*, *AND*, et *OR*. Les règles définies dans cette section seront utilisées ultérieurement avec les fonctions *NOT*, *AND* et *OR* qui seront complétées dans cette section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Voici les deux premières règles qui seront examinées dans le reste du Notebook.     \n",
    "***\n",
    "*Règle 1* - Si c’est le *week-end* et que je suis *Très occupé*, je vais aller au *Yoga* (If it is the *Weekend* and I am *Very Busy*, I will go to *Yoga*)\n",
    "            \n",
    "*Règle 2* - Si c’est le *Week-end* et que je suis un *Peu Occupé* ou *Modérément Occupé*, je vais aller au *Ski* (If it is the *Weekend* and I am a *Little Busy* or *Moderately Busy*, I will go to *Ski*)\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(TO DO) Q4 - 1 point**  \n",
    "\n",
    "Dans cette cellule, définissez une 3ième règle de votre choix en français.  Votre règle doit contenir *exactement un opérateur flou OR*, avec *exactement un opérateur flou NOT*, et où la conséquence est l’activité *Play Games*.   \n",
    "***        \n",
    "*Règle 3* - Si ce n'est pas le Week-end ou je suis Modérément Occupé, je vais jouer aux jeux.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ensuite, les opérateurs de logique floue doivent tous être implémentés. La fonction (complète) *fuzzy_NOT* suivante est fournie comme exemple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fuzzy_NOT(num):\n",
    "    '''\n",
    "    Provides the returned result for the fuzzy logic NOT operator.\n",
    "    num1: The first membership value\n",
    "    num2: The second membership value\n",
    "    returns the numerical fuzzy_NOT operator's result when applied on num1 and num2 rounded to\n",
    "        the second decimal place (due to floating point imprecisions)\n",
    "    '''\n",
    "    return round(1 - num, 2) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(TO DO) Q5 - 2 points**  \n",
    "\n",
    "Dans les deux cellules ci-dessous, complétez les définitions des fonctions fuzzy_OR et fuzzy_AND. Pour plus de détails sur ces fonctions, consultez vos notes de cours."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Complete the function\n",
    "def fuzzy_OR(num1,num2):\n",
    "    '''\n",
    "    Provides the returned result for the fuzzy logic OR operator.    \n",
    "    '''\n",
    "    return max(num1, num2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Complete the function\n",
    "def fuzzy_AND(num1,num2):\n",
    "    '''\n",
    "    Provides the returned result for the fuzzy logic AND operator.\n",
    "    '''\n",
    "    return min(num1, num2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4. Fuzzification.**  \n",
    "La première étape pour résoudre un problème est d’effectuer la *fuzzification*. Ce processus a déjà été programmé pour vous dans la classe LinguisticVariable. Cette fonction *.fuzzification(fs_name, x)* nécessite le nom du sous-ensemble flou et la valeur dont vous souhaitez obtenir l’appartenance du sous-ensemble flou à l’entrée."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jetons un coup d’œil à l’exemple de fuzzification suivant. Ceci fuzzifie l’instruction suivante:   \n",
    "*C’est jeudi et ce premier module me prendra 2,5 heures à faire.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is Thursday and this first module will take me 2.5 hours to do.\n",
      "Thursday has the membership 0.3 for being the Weekend.\n",
      "2.5 hours has the membership 0.5 for being Little busy\n",
      "2.5 hours has the membership 0.25 for being Moderate busy\n",
      "2.5 hours has the membership 0 for being Very busy\n"
     ]
    }
   ],
   "source": [
    "print(\"It is Thursday and this first module will take me 2.5 hours to do.\")\n",
    "# The first value is Thursday, so we will get the membership of weekend for the value Thursday\n",
    "weekend_membership_test = day_lv.fuzzification(\"Weekend\", \"Thursday\")\n",
    "print(\"Thursday has the membership \" + str(weekend_membership_test) + \" for being the Weekend.\")\n",
    "# The second value is that the work will be 2.5 hours, so how Little, Moderate, and Very busy is that?\n",
    "little_membership_test = busy_lv.fuzzification(\"Little\", 2.5)\n",
    "print(\"2.5 hours has the membership \" + str(little_membership_test) + \" for being Little busy\")\n",
    "moderate_membership_test = busy_lv.fuzzification(\"Moderate\", 2.5)\n",
    "print(\"2.5 hours has the membership \" + str(moderate_membership_test) + \" for being Moderate busy\")\n",
    "very_membership_test = busy_lv.fuzzification(\"Very\", 2.5)\n",
    "print(\"2.5 hours has the membership \" + str(very_membership_test) + \" for being Very busy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ATTENTION --- Le problème que nous voudrons résoudre à partir de maintenant est le suivant: \n",
    "***\n",
    "\n",
    "    Déclaration du problème: C’est vendredi et j’ai encore 4 heures de travail à faire. Quelle activité vais-je faire et pour combien de temps?\n",
    "***\n",
    "    \n",
    "Ce problème sera utilisé pour les prochaines sections, alors assurez-vous de vous y référer en cas de besoin. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(TO DO) Q6 - 2 points**\n",
    "\n",
    "Effectuez la fuzzification pour le problème (défini ci-dessus) dans la cellule ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Friday has the membership 0.7 for being the Weekend\n",
      "4 hours has the membership 0 for being Little Busy\n",
      "4 hours has the membership 1.0 for being Moderate Busy\n",
      "4 hours has the membership 0 for being Very Busy\n"
     ]
    }
   ],
   "source": [
    "# TODO: Add in the fuzzification calls for the appropriate linguistic variables.\n",
    "# Weekend fuzzification\n",
    "weekend_membership = day_lv.fuzzification(\"Weekend\" , \"Friday\")\n",
    "print(\"Friday has the membership \" + str(weekend_membership) + \" for being the Weekend\")\n",
    "# Little fuzzification\n",
    "little_membership = busy_lv.fuzzification(\"Little\" , 4)\n",
    "print(\"4 hours has the membership \" + str(little_membership) + \" for being Little Busy\")\n",
    "# Moderate fuzzification\n",
    "moderate_membership = busy_lv.fuzzification(\"Moderate\" , 4)\n",
    "print(\"4 hours has the membership \" + str(moderate_membership) + \" for being Moderate Busy\")\n",
    "# Very fuzzification\n",
    "very_membership = busy_lv.fuzzification(\"Very\" , 4)\n",
    "print(\"4 hours has the membership \" + str(very_membership) + \" for being Very Busy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5. Application des règles d'inférences ou de raisonnements.**  \n",
    "\n",
    "Maintenant que la fuzzification de l’énoncé du problème est terminée, nous pouvons commencer à appliquer les opérateurs de logique floue qui ont été programmés ci-dessus en nous servant des règles que nous avons définies dans la partie 3 de ce notebook.     \n",
    "\n",
    "Vous trouverez ci-dessous un exemple d’application des opérateurs de la règle 1 avec les données de fuzzification de l’étape précédente.  \n",
    "\n",
    "Lors de l’application des règles d’inférence, nous établissons la priorité suivante (ordre d’application des opérateurs):   \n",
    "1. fuzzy_NOT: Toutes les instances de NOT doivent être appliquées en premier\n",
    "2. fuzzy_OR : Toutes les instances de OR doivent être appliquées ensuite\n",
    "3. fuzzy_AND: Toutes les instances de AND doivent être appliquées en dernier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rule 1 - If it is the Weekend and I am Very Busy, I will go to Yoga.\n",
      "The membership value for Yoga is 0\n"
     ]
    }
   ],
   "source": [
    "print(\"Rule 1 - If it is the Weekend and I am Very Busy, I will go to Yoga.\")\n",
    "# If it is the Weekend AND I am Very busy -> What is the membership of going to yoga\n",
    "rule1_membership_test = fuzzy_AND(weekend_membership_test, very_membership_test)\n",
    "print(\"The membership value for Yoga is \" + str(rule1_membership_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(TO DO) Q7 - 2 points**  \n",
    "\n",
    "Pour chacune des trois règles définies dans la partie 3 de ce notebook, les deux fournies et celle que vous avez écrite, appliquez correctement les opérateurs pour mettre en place les règles. Cela doit être fait dans la cellule ci-dessous, avec les résultats formatés comme on le voit dans l’exemple ci-dessus. La règle 1 a été indiquée dans la cellule précédente et a déjà été définie pour vous ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rule 1 - If it is the Weekend and I am Very Busy, I will go to Yoga.\n",
      "The membership value for Yoga is 0\n",
      "Rule 2 - If it is the Weekend and I am a Little Busy or Moderately Busy, I will go to Ski.\n",
      "The membership value for Ski is 0.7\n",
      "Rule 3 - If it is not the Weekend or I am Moderately Busy, I will Play games\n",
      "The membership value for Play games is 1.0\n"
     ]
    }
   ],
   "source": [
    "# RULE 1\n",
    "print(\"Rule 1 - If it is the Weekend and I am Very Busy, I will go to Yoga.\")\n",
    "rule1_membership = fuzzy_AND(weekend_membership, very_membership)\n",
    "print(\"The membership value for Yoga is \" + str(rule1_membership))\n",
    "\n",
    "#TODO\n",
    "# RULE 2\n",
    "print(\"Rule 2 - If it is the Weekend and I am a Little Busy or Moderately Busy, I will go to Ski.\")\n",
    "rule2_membership = fuzzy_AND(weekend_membership, fuzzy_OR(little_membership , moderate_membership))\n",
    "print(\"The membership value for Ski is \" + str(rule2_membership))\n",
    "\n",
    "#TODO\n",
    "# RULE 3\n",
    "print(\"Rule 3 - If it is not the Weekend or I am Moderately Busy, I will Play games\")\n",
    "rule3_membership = fuzzy_OR(fuzzy_NOT(weekend_membership), moderate_membership)\n",
    "print(\"The membership value for Play games is \" + str(rule3_membership))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(TO DO) Q8 - 2 points**  \n",
    "\n",
    "Nous devons maintenant transférer le degré d'appartenance de l’antécédent sur la conséquence de chaque règle. Cela se fait en appelant la fonction LinguisticVariable.set_fuzzy_maximum(fs_name, x). Cette fonction transfère le degré d’adhésion x à un sous-ensemble flou dont le nom est fs_name (dans ce cas, la conséquence).   \n",
    "\n",
    "Votre tâche consiste à transférer les adhésions obtenues ci-dessus sur les sous-ensembles flous d’activité correspondants."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Transfer the membership degrees to the activity_lv fuzzy subsets \n",
    "yoga_membership = activity_lv.set_fuzzy_maximum(\"Yoga\", rule1_membership)\n",
    "ski_membership = activity_lv.set_fuzzy_maximum(\"Ski\" , rule2_membership)\n",
    "play_games_membership = activity_lv.set_fuzzy_maximum(\"Play games\", rule3_membership)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**6. Défuzzification.**  \n",
    "\n",
    "La dernière étape pour résoudre l’énoncé de problème est d’effectuer la défuzzification. Ce processus consiste à prendre une entrée floue et à produire une sortie nette basée sur l’une des nombreuses méthodes potentielles. Pour ce notebook, nous utiliserons la moyenne des valeurs de l'axe x pour lesquelles apparaissent les valeurs maximales trouvées sur l’axe y. Bien que des méthodes plus robustes existent, nous allons simplement récupérer les emplacements des valeurs maximales en récupérant de nombreux points clés du graphe et en faisant la moyenne des valeurs x qui produisent la valeur y maximale.   \n",
    "  \n",
    "Dans la section précédente, vous avez transféré les adhésions que vous avez obtenues pour qu'elles soient le degré d’adhésion maximum de la conséquence. Ainsi, la valeur maximale y apparaît à chaque point supérieur ou égal à l’appartenance transférée (s’il y en a), ou à la valeur maximale globale autrement.   \n",
    "\n",
    "La défuzzification doit être appliquée *uniquement* au sous-ensemble flou qui contient le plus haut transfert"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(TO DO) Q9 - 4 points**   \n",
    "\n",
    "Votre tâche est maintenant d’effectuer le processus de défuzzification et de répondre à l’énoncé de problème. Il s’agit de trois parties que vous devez compléter.    \n",
    " \n",
    "1. Trouvez quel sous-ensemble flou correspondant à la variable linguistique Activity contient la valeur d’adhésion la plus haute ou importante après le transfert d’adhésion que vous avez effectué à la question 8. Vous pouvez accéder à la valeur d’appartenance maximale d’un sous-ensemble flou dans une variable linguistique en appelant *LinguisticVariable.get_fuzzy_maximum(fs_name)*, où fs_name est le nom du sous-ensemble flou. Vous devez imprimer le nom du sous-ensemble flou avec la valeur d’appartenance la plus importante (à partir des appels de fonction) et la valeur d’accompagnement.     \n",
    "2. Pour seul le sous-ensemble flou qui contient la valeur d’appartenance maximale (l’activité sélectionnée), effectuez la défuzzification sur son adhésion maximale pour obtenir la sortie nette. Pour effectuer cette défuzzification en effectuant la moyenne des maxima, appelez la fonction *LinguisticVariable.defuzzification_average_maximas(fs_name)*, où fs_name est le nom du sous-ensemble de la variable floue. Imprimez la sortie nette.     \n",
    "3. À partir de ce qui précède, remplissez la cellule fournie avec la solution à l’instruction de problème (quelle activité sera effectuée et pour combien de temps). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum membership is 1 for the fuzzy subset Play games\n"
     ]
    }
   ],
   "source": [
    "# (TO DO) Q9 - Part 1\n",
    "# TODO: Determine which fuzzy subset contains the maximum membership value\n",
    "# Transférer le degreé d'appartenance à l'ensemnble flou Yoga\n",
    "max_yoga = activity_lv.get_fuzzy_maximum(\"Yoga\")\n",
    "\n",
    "# Transférer le degreé d'appartenance à l'ensemnble flou Ski\n",
    "max_ski = activity_lv.get_fuzzy_maximum(\"Ski\")\n",
    "\n",
    "# Transférer le degreé d'appartenance à l'ensemnble flou Play games\n",
    "max_play_games = activity_lv.get_fuzzy_maximum(\"Play games\")\n",
    "\n",
    "# Trouver l'ensemble flou qui a le niveau d'appartenance le plus élevée\n",
    "max_value = max(max_yoga, max_ski, max_play_games)\n",
    "fsname=\"\"\n",
    "if max_value == max_yoga:\n",
    "    fsname = \"Yoga\"\n",
    "elif max_value == max_ski:\n",
    "    fsname = \"Ski\"\n",
    "else:\n",
    "    fsname = \"Play games\"\n",
    "\n",
    "...\n",
    "# TODO: Print the maximum mebership value and the name of the fuzzy subset\n",
    "print(\"The maximum membership is \" + str(max_value) + \" for the fuzzy subset \" + fsname)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The defuzzification value is 9.0\n"
     ]
    }
   ],
   "source": [
    "# (TO DO) Q9 - Part 2\n",
    "# TODO: Perform the defuzzification\n",
    "defuzz = activity_lv.defuzzification_average_maximas(fsname)\n",
    "# TODO: Print the crisp output | Écrivez la sortie nette\n",
    "print(\"The defuzzification value is \" +str(defuzz))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(TO DO) Q9 - Part 3**     \n",
    "Écrivez la réponse au problème ici.     \n",
    "L'activité choisie est \"Play games\" pour une durée de 9 heures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**7. Résoudre votre propre problème.**  \n",
    "\n",
    "Maintenant que vous avez terminé l’ensemble du processus de résolution d’un problème avec une logique floue, vous travaillerez avec un nouveau problème pour le résoudre par l’utilisation des variables linguistiques et des règles que nous avons définies ci-dessus. Voici chaque étape que vous devrez faire dans les cellules ci-dessous.\n",
    "\n",
    "**(TO DO) Q10 - 9 points**  \n",
    "\n",
    "L’énoncé du problème que vous résoudrez par vous-même est :   \n",
    "***   \n",
    "    Déclaration du problème: C’est dimanche et j’ai encore 7 heures de travail à faire. Quelle activité vais-je faire et pour combien de temps?\n",
    "***   \n",
    "     \n",
    "1. Effectuer la fuzzification et imprimer les résultats de la fuzzification.    \n",
    "2. Appliquer les opérateurs de logique floue sur l’antécédent des trois règles utilisées dans ce notebook.    \n",
    "3. Transférer le degré d’appartenance de l’antécédent sur la conséquence.\n",
    "4. Effectuer la défuzzification et imprimer la réponse au problème (ne pas oublier de trouver l’appartenance maximale)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Reset max_membership variable for all fuzzy sets in all linguistic variables\n",
    "# This must be called to properly reset the state of the linguistic variable.\n",
    "day_lv.reset_fuzzy_maximums()\n",
    "busy_lv.reset_fuzzy_maximums()\n",
    "activity_lv.reset_fuzzy_maximums()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "# (TO DO) Q10 - Part 1\n",
    "# Perform the fuzzification here and print the results\n",
    "weekend_appartenance = day_lv.fuzzification(\"Weekend\" , \"Sunday\")\n",
    "little_appartenance = busy_lv.fuzzification(\"Little\" , 7)\n",
    "moderate_appartenance = busy_lv.fuzzification(\"Moderate\" , 7)\n",
    "very_appartenance = busy_lv.fuzzification(\"Very\" , 7)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rule 1 - If it is the Weekend and I am Very Busy, I will go to Yoga.\n",
      "The membership value for Yoga is 0.5\n",
      "Rule 2 - If it is the Weekend and I am a Little Busy or Moderately Busy, I will go to Ski.\n",
      "The membership value for Ski is 0\n",
      "Rule 3 - If it is not the Weekend or I am Moderately Busy, I will Play games\n",
      "The membership value for Play games is 0.05\n"
     ]
    }
   ],
   "source": [
    "# (TO DO) Q10 - Part 2\n",
    "# Apply the fuzzy logic operators on the antecedent of the three rules used throughout this notebook\n",
    "\n",
    "# TODO\n",
    "# RULE 1\n",
    "print(\"Rule 1 - If it is the Weekend and I am Very Busy, I will go to Yoga.\")\n",
    "rule1_membership = fuzzy_AND(weekend_appartenance, very_appartenance)\n",
    "print(\"The membership value for Yoga is \" + str(rule1_membership))\n",
    "\n",
    "#TODO\n",
    "# RULE 2\n",
    "print(\"Rule 2 - If it is the Weekend and I am a Little Busy or Moderately Busy, I will go to Ski.\")\n",
    "rule2_membership = fuzzy_AND(weekend_appartenance, fuzzy_OR(little_appartenance, moderate_appartenance))\n",
    "print(\"The membership value for Ski is \" + str(rule2_membership))\n",
    "\n",
    "#TODO\n",
    "# RULE 3\n",
    "print(\"Rule 3 - If it is not the Weekend or I am Moderately Busy, I will Play games\")\n",
    "rule3_membership = fuzzy_OR(fuzzy_NOT(weekend_appartenance), moderate_appartenance)\n",
    "print(\"The membership value for Play games is \" + str(rule3_membership))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [],
   "source": [
    "# (TO DO) Q10 - Part 3\n",
    "# Transfer the membership degree of the antecedent on the consequence\n",
    "yoga_membership = activity_lv.set_fuzzy_maximum(\"Yoga\", rule1_membership)\n",
    "ski_membership = activity_lv.set_fuzzy_maximum(\"Ski\" , rule2_membership)\n",
    "play_games_membership = activity_lv.set_fuzzy_maximum(\"Play games\", rule3_membership)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The maximum membership is 0.5 for the fuzzy subset Yoga\n",
      "I will do Yoga for 1.625 hours.\n"
     ]
    }
   ],
   "source": [
    "# Perform the defuzzification process\n",
    "# TODO: First find the maximum\n",
    "max_yoga = activity_lv.get_fuzzy_maximum(\"Yoga\")\n",
    "max_ski = activity_lv.get_fuzzy_maximum(\"Ski\")\n",
    "max_play_games = activity_lv.get_fuzzy_maximum(\"Play games\")\n",
    "max_value = max(max_yoga, max_ski, max_play_games)\n",
    "fsname=\"\"\n",
    "if max_value == max_yoga:\n",
    "    fsname = \"Yoga\"\n",
    "elif max_value == max_ski:\n",
    "    fsname = \"Ski\"\n",
    "else:\n",
    "    fsname = \"Play games\"\n",
    "# TODO: Print the maximum mebership value and the name of the fuzzy subset\n",
    "print(\"The maximum membership is \" + str(max_value) + \" for the fuzzy subset \" + fsname)\n",
    "# TODO: Perform the defuzzification\n",
    "defuzz = activity_lv.defuzzification_average_maximas(fsname)\n",
    "# Print the answer to the problem\n",
    "print(\"I will do \" + fsname + \" for \" + str(defuzz) + \" hours.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***SIGNATURE:***  Mon nom est --Bhavika Sewpal-------, et mon numéro d'étudiant(e) est -300089940--------.  Je certifie être l'auteur de ce devoir."
   ]
  },
  {
   "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}