ALG02-Conjuntos_COMPLETO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/keepcoding.png\" width=200 align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/me.jpg\" width=150 align=\"right\">\n",
    "\n",
    "# Conjuntos: Teoría y Práctica\n",
    "\n",
    "Autor: Carlos Moreno Morera\n",
    "\n",
    "Contacto: carlos.moreno@ibm.com\n",
    "\n",
    "Última revisión: 09/Jul/2022"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.- Introducción y ejemplos\n",
    "\n",
    "### 1.1.- Definición\n",
    "\n",
    "Un conjunto se define como un objeto que consiste en una **colección bien definida de objetos**, entendiendo que dichos objetos, llamados **elementos** (o miembros) **del conjunto**, pueden definirse de manera arbitraria como, por ejemplo, números, personas, letras, marcas, planetas e, incluso, otros conjuntos. Algunos ejemplos sencillos de conjuntos son:\n",
    "- El conjunto de las 10 búsquedas con más peticiones de Google\n",
    "- El conjunto de los continentes de la Tierra\n",
    "- El conjunto de los días de la semana\n",
    "- El conjunto de granos de arena en La Playa de Las Catedrales\n",
    "- El conjunto de átomos del universo\n",
    "- El conjunto de posibles frases que pueden construirse\n",
    "\n",
    "De estos ejemplos anteriores, todos, a excepción del último, son conjuntos finitos (aunque la cantidad de elementos que poseen pueda ser gigantesca, sigue siendo un número finito), pero todos están bien definidos como colecciones de objetos. Sin embargo, a diferencia de estos, conjunto de los 10 pueblos más bonitos de España no es una colección bien definida, pues basa su construcción en una definición subjetiva o que no nos permite establecer una relación de pertenencia sin ambigüedades.\n",
    "\n",
    "<img src=\"./images/comp_set.png\">\n",
    "\n",
    "Estas entidades matemáticas, son **conceptos primitivos** en el sentido de que no es posible definirlos en términos de nociones más elementales, por lo que su estudio se realiza de manera informal, apelando a la intuición y a la lógica. Por otro lado, son el concepto fundamental de la matemática: mediante ellos puede formularse el resto de objetos matemáticos, como los números y las funciones (ambos los estudiaremos más adelante), entre otros.\n",
    "\n",
    "En lenguaje matemático, los conjuntos vienen definidos por llaves con los elementos separados por comas. Así, si $A$ es el conjunto de los números uno, dos y tres, se escribirá:\n",
    "$$\n",
    "A=\\{1,2,3\\}\n",
    "$$\n",
    "En Python, podremos definir conjuntos de elementos de la misma forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "#Definimos el conjunto A como lo hicimos matemáticamente en Python\n",
    "A = {1,2,3}\n",
    "print(A)\n",
    "print(type(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "    <b>⚠️ ATENCIÓN ⚠️</b> ¡Es imprescindible poner los corchetes!\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Veamos qué ocurre si no los ponemos\n",
    "1,2,3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se observa, si obviamos los corchetes obtendremos una tupla en lugar de un objeto de la clase *set*, que, como veremos más adelante, son objetos radicalmente distintos con propiedades, características y operaciones completamente diferentes.\n",
    "\n",
    "Cuando definimos un conjunto matemáticamente a través de sus elementos (veremos otra forma de definir un conjunto más adelante), hay que tener en cuenta que no existe ninguna restricción para que compartan ninguna propiedad, característica o tipo. De esta forma podríamos tener el conjunto $S$ de los días de la semana:\n",
    "$$\n",
    "S=\\{\\text{lunes}, \\text{martes}, \\text{miércoles}, \\text{jueves}, \\text{viernes}, \\text{sábado}, \\text{domingo}\\}\n",
    "$$\n",
    "o el conjunto $B$ que tiene los siguientes elementos:\n",
    "$$\n",
    "B=\\{\\text{martes}, -73, \\text{Lorca}, (\\text{on}, \\text{off}), True\\}\n",
    "$$\n",
    "Como vemos el conjunto $B$ posee elementos distintos (un día de la semana, un número entero, un escritor, una tupla con dos elementos y un valor booleano) y se considera bien definido, ya que tenemos forma de conocer si dado un elemento cualquiera pertenece o no a $B$. En Python también podemos definir el conjunto $S$ y $B$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'domingo', 'jueves', 'lunes', 'martes', 'miércoles', 'sábado', 'viernes'}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Definimos el conjunto S\n",
    "S = {'lunes', 'martes', 'miércoles', 'jueves', 'viernes', 'sábado', 'domingo'}\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('on', 'off'), -73, 'Lorca', True, 'martes'}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Definimos el conjunto B\n",
    "B = {'martes', -73, 'Lorca', ('on', 'off'), True}\n",
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos definir conjuntos a partir de listas u otras estructuras de datos utilizando `set`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Convertimos la lista [0,1,2] en un conjunto\n",
    "set([0,1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'off', 'on'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Convertimos la tupla ('on', 'off') en un conjunto\n",
    "set(('on', 'off'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.- Colecciones desordenadas\n",
    "\n",
    "Si observamos detenidamente los resultados de la implementación en Python, veremos que los elementos no se muestran en el mismo orden que los definimos. Esto, se debe a que matemáticamente los conjuntos son colecciones de elementos, independientemente de su orden, es decir, que un conjunto viene definido por sus elementos. De esta forma, podremos decir que el conjunto $A$ anteriormente definido, es el mismo conjunto que el conjunto $C$ definido como $C=\\{1,3,2\\}$, o lo que es lo mismo:\n",
    "$$\n",
    "A=\\{1,2,3\\}=\\{1,3,2\\}=C\n",
    "$$\n",
    "Sin embargo, $A$ no sería el mismo conjunto que $D=\\{1,2\\}$, que $E=\\{1,2,3,4\\}$ ni que $S$. Veamos que Python respeta esta definición matemática:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Definimos C y comparamos si es igual a A\n",
    "C = {1,3,2}\n",
    "A == C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#Veamos que, en efecto, Python compara los conjuntos elemento a elemento y comparemos A con E, D y S\n",
    "D = {1, 2}\n",
    "E = {1, 2, 3, 4}\n",
    "print(A == D)\n",
    "print(A == E)\n",
    "print(A == S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De esta forma, podemos afirmar que en Python los conjuntos, a diferencia de las listas y tuplas, **son colecciones de elementos desordenadas**.\n",
    "\n",
    "### 1.3.- Conjuntos de conjuntos (frozenset)\n",
    "\n",
    "Como hemos visto en la definición y con el conjunto de ejemplo $B$, los elementos pueden ser de cualquier tipo que se nos ocurra, incluso otros conjuntos. Definamos, por ejemplo, el conjunto $U$ como una colección de conjuntos de números:\n",
    "$$\n",
    "U=\\{\\{1,2\\},\\{1\\}, \\{-1,0,1\\}\\}\n",
    "$$\n",
    "De esta manera, el conjunto $U$ posee tres elementos, los cuales son conjuntos. Veámoslo en Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'set'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-d0d68e0ca7e5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#Definimos el conjunto U como se ha visto teóricamente\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mU\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m{\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mU\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: unhashable type: 'set'"
     ]
    }
   ],
   "source": [
    "#Definimos el conjunto U como se ha visto teóricamente\n",
    "U = {{1,2}, {1}, {-1, 0, 1}}\n",
    "U"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como puede observarse, aunque matemáticamente es posible definir conjuntos dentro de conjuntos, la implementación en Python no nos lo permite debido a que requiere que los elementos del conjunto (en este caso otros conjuntos) sean *hashable*, o lo que es lo mismo, puedan ser argumentos de una función *hash* (más adelante profundizaremos en este tema). Una de las condiciones para que en Python un objeto sea *hashable* es que no sea **mutable** (es decir, cambiante, lo que significa que no se puedan añadir, borrar o actualizar sus elementos), o lo que es lo mismo, que sea **inmutable** como lo son las variables numéricas, cadenas de caracteres y tuplas. Las listas, conjuntos y diccionarios (que se tratan más adelante) son mutables.\n",
    "\n",
    "Para definir en Python el conjunto $U$, se suelen utilizar una solución que nos da el lenguaje: convertir los conjuntos en objetos inmutables. Para crear conjuntos inmutables (a los que no se les pueden añadir elementos, ni borrar ni actualizar) utilizamos los `frozenset`, que generan conjuntos inmutables. Así, definimos $U$ de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{frozenset({1}), frozenset({-1, 0, 1}), frozenset({1, 2})}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Definimos U con frozenset\n",
    "U = {frozenset({1,2}), frozenset({1}), frozenset({-1, 0, 1})}\n",
    "U"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De esta manera, también podríamos definir varios niveles de conjuntos. Por ejemplo, implementemos en Python el conjunto $V$ definido a continuación:\n",
    "$$\n",
    "V=\\left\\{\\left\\{\\{1,2\\}, \\{1\\}, \\{-1,0,1\\}\\right\\},\\{3\\},\\{0\\}\\right\\} = \\{U, \\{3\\},\\{0\\}\\}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{frozenset({3}),\n",
       " frozenset({frozenset({1}), frozenset({-1, 0, 1}), frozenset({1, 2})}),\n",
       " frozenset({0})}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Definimos V\n",
    "V = {frozenset({frozenset({1,2}), frozenset({1}), frozenset({-1, 0, 1})}), frozenset({3}), frozenset({0})}\n",
    "V"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4.- Unicidad de los elementos\n",
    "Los conjuntos en matemáticas se utilizan para englobar un conjunto de elementos y determinar la pertenencia de ellos. Por este motivo, como se ha visto en el apartado 1.2, no es necesario que sus elementos estén sujetos a un orden. Otra consecuencia de este uso, es que en un conjunto cada elemento se presenta una única vez (en caso de que puedan aparecer en más de una ocasión se denomina *multiconjunto* y se trata de otra entidad matemática más compleja y avanzada). De esta forma, no es correcto definir un conjunto que contenga elementos repetidos. Veamos qué ocurre cuando lo introducimos en Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 9}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = {3,3,9,2}\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se puede observar, Python es consecuente con la definición matemática de conjunto y elimina las duplicidades que puedan aparecer. Lo mismo ocurriría si introducimos elementos que son iguales tras su evaluación, por ejemplo insertando operaciones para calcular los elementos de un conjunto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, '3'}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1+2, 3, '3'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5.- Recorrer los elementos de un conjunto\n",
    "Al igual que con otras estructuras de datos como las listas, podemos recorrer todos los elementos de un conjunto utilizando un bucle for:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "#Hacemos print de todos los elementos del conjunto A\n",
    "for elemento in A:\n",
    "    print(elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, como hemos explicado, al no ser el conjunto una colección ordenada de elementos (como lo son las listas) el operador de indexación (los corchetes) no funcionará correctamente dado que \"no existe el concepto de elemento en la posición n-ésima\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-15-72ea7112faa4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mA\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'set' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "A[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.6.- Definición intensiva\n",
    "Como hemos visto, una manera de definir los conjuntos es listando todos y cada uno de sus elementos explícitamente. Esta manera de mostrar los conjuntos se conoce como definición extensiva o notación extensiva. Sin embargo, lo más habitual es determinar sus elementos (y por tanto definirlo) a través de una propiedad o característica que deben poseer todos ellos, es decir, una propiedad o característica que determina la pertenencia a dicho conjunto.\n",
    "\n",
    "Para ello, lo primero que debe hacerse es coger un conjunto bien definido, y tomar algunos de sus elementos en función de una propiedad o característica. Por ejemplo, en la imagen observamos un conjunto de polígonos que podríamos denotar por $P$ y podríamos definir otro conjunto que esté conformado por los elementos de $P$ que sean regulares.\n",
    "\n",
    "<img src=\"./images/polygon_set.png\">\n",
    "\n",
    "Este tipo de construcción de conjunto en la que, en lugar de indicar los elementos individualmente, se determinan sus elementos a través de una propiedad común, se denomina definición intensiva o por comprensión. Matemáticamente utilizan una notación un poco distinta a la que usábamos en la definición extensiva. Por ejemplo, si queremos definir un conjunto $C$ que englobe aquellas cartas de la baraja francesa cuyo palo sea de color rojo, el conjunto inicial que estamos eligiendo y del que tomaremos ciertos elementos es el conjunto de las cartas de la baraja francesa. Entonces escribiríamos matemática $C$ de la siguiente forma:\n",
    "$$\n",
    "C = \\{c : c\\text{ es una carta de la baraja francesa y su palo es rojo}\\}\n",
    "$$\n",
    "En este tipo de expresiones, los dos puntos (\":\") significan \"tal que\". En lugar de los dos puntos se utiliza también la barra vertical \"|\" u oblicua \"/\". En Python, cuando partimos de un conjunto inicial, podemos construir el conjunto $C$ de la misma forma que se definen las listas por comprensión:\n",
    "$$\n",
    "\\{\\text{expresión for elemento in conjunto}\\}\n",
    "$$\n",
    "De forma opcional se puede incluir un filtro para solo añadir al conjunto los elementos que cumplan una condición:\n",
    "$$\n",
    "\\{\\text{expresión for elemento in conjunto if condición}\\}\n",
    "$$\n",
    "Pongámoslo en práctica:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{('J', 'd'), (9, 'c'), (7, 'd'), (2, 'c'), (6, 'c'), ('K', 'c'), (9, 'd'), (4, 'c'), (2, 'd'), (8, 'c'), (10, 'c'), (6, 'd'), (5, 'd'), (1, 'c'), ('K', 'd'), (4, 'd'), (8, 'd'), (3, 'c'), (10, 'd'), (5, 'c'), ('Q', 'c'), (1, 'd'), ('J', 'c'), (7, 'c'), (3, 'd'), ('Q', 'd')}\n"
     ]
    }
   ],
   "source": [
    "Cartas = {(1, 'c'), (1, 'd'), (1, 'p'), (1, 't'), (2, 'c'), (2, 'd'), (2, 'p'), (2, 't'), (3, 'c'), (3, 'd'), (3, 'p'), \n",
    "          (3, 't'), (4, 'c'), (4, 'd'), (4, 'p'), (4, 't'), (5, 'c'), (5, 'd'), (5, 'p'), (5, 't'), (6, 'c'), (6, 'd'), \n",
    "          (6, 'p'), (6, 't'), (7, 'c'), (7, 'd'), (7, 'p'), (7, 't'), (8, 'c'), (8, 'd'), (8, 'p'), (8, 't'), (9, 'c'), \n",
    "          (9, 'd'), (9, 'p'), (9, 't'), (10, 'c'), (10, 'd'), (10, 'p'), (10, 't'), ('J', 'c'), ('J', 'd'), ('J', 'p'), \n",
    "          ('J', 't'), ('Q', 'c'), ('Q', 'd'), ('Q', 'p'), ('Q', 't'), ('K', 'c'), ('K', 'd'), ('K', 'p'), ('K', 't')}\n",
    "#Dado el conjunto \"Cartas\" con todas las cartas de la baraja francesa, definimos C con notación intensiva:\n",
    "C = {carta for carta in Cartas if carta[1] == 'c' or carta[1] == 'd'}\n",
    "print(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aunque matemáticamente sea necesario partir de un conjunto inicial para definir por comprensión otro conjunto, en Python podemos partir de otras estructuras de datos como listas y tuplas para crearlos. Así, la construcción de conjuntos por comprensión queda de la siguiente forma:\n",
    "$$\n",
    "\\{\\text{expresión for elemento in estructura_de_datos if condición}\\}\n",
    "$$\n",
    "siendo la condición opcional. De esta manera, en lugar de construir el conjunto de cartas elemento a elemento podemos llevar a cabo una definición intensiva del mismo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Definimos el conjunto de Cartas anterior por comprensión\n",
    "valores = (list(range(1, 11)) + ['J', 'Q', 'K']) * 4\n",
    "palos = ['c', 'd', 'p', 't'] * 13\n",
    "\n",
    "Cartas_comp = {(v, p) for v, p in zip(valores, palos)}\n",
    "Cartas_comp == Cartas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin duda poder generar por comprensión conjuntos grandes en Python facilita la tarea enormemente. A continuación definiremos matemáticamente otros conjuntos que vamos a implementar en Python con el fin de practicar la definición intensiva:\n",
    "$$\n",
    "I = \\{a + 1:a\\text{ es un elemento de A}\\}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Conjunto conformado por los elementos del conjunto A sumándole 1\n",
    "{elemento + 1 for elemento in A}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "E^2 = \\{e^2:e\\text{ es un elemento par de E}\\}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 16}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Conjunto conformado por los elementos del conjunto E elevados al cuadrado, pero solo aquellos que sean pares\n",
    "{elemento**2 for elemento in E if elemento % 2 == 0}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Construyamos ahora conjuntos por comprensión desde otras estructuras de datos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'c', 'e', 'i', 'm', 's', 't', 'á'}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# El conjunto de las letras de la palabta \"matemáticas\"\n",
    "{letra for letra in 'matemáticas'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 6, 10, 14, 18, 22, 26, 30, 34, 38}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# El conjunto de números naturales impares menores que 20 multiplicados por 2\n",
    "{n * 2 for n in range(20) if n % 2 == 1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{(3, 4), (4, 6), (2, 2), (1, 6), (2, 5), (1, 3), (4, 5), (3, 3), (5, 6), (3, 6), (2, 4), (1, 2), (1, 5), (3, 5), (4, 4), (5, 5), (1, 1), (1, 4), (2, 3), (2, 6), (6, 6)}\n"
     ]
    }
   ],
   "source": [
    "# El conjunto de las posibles combinaciones de resultados al tirar dos dados de 6 caras\n",
    "numeros_dados = list(range(1,7)) * 6\n",
    "numeros_dados.sort()\n",
    "print({(d1, d2) for d1, d2 in zip(list(range(1,7)) * 6, numeros_dados) if d1 <= d2})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.7.- Conjunto vacío\n",
    "El conjunto que no contiene ningún elemento se denomina conjunto vacío y se denota por $\\emptyset$ o simplemente $\\{\\}$. Una curiosidad de este conjunto es que el único sobre el que puede realizarse una afirmación y su negación y que ambas sean ciertas y falsas a la vez. En Python, hay que tener cuidado porque no podemos definir el conjunto vacío con llaves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Si intentamos definir el conjunto vacío con llaves no obtendremos lo que buscamos\n",
    "type({})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Para no obtener un diccionario vacío, deberemos usar set()\n",
    "vacio = set()\n",
    "vacio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.- Relación de pertenencia, comparación de conjuntos y subconjuntos\n",
    "\n",
    "### 2.1.- Pertenencia\n",
    "Como hemos visto, un conjunto se define a partir de los elementos que lo componen (incluso si no posee ninguno). Por lo tanto es importante conocer cuándo un elemento pertenece o no a un conjunto.\n",
    "\n",
    "<img src=\"./images/membership.png\">\n",
    "\n",
    "Para ello en matemáticas se cuenta con el símbolo $\\in$ el cual determina que el elemento está en el conjunto. Por ejemplo, podemos decir:\n",
    "$$\n",
    "2\\in A\n",
    "$$\n",
    "Y por el contrario también podemos afirmar:\n",
    "$$\n",
    "0\\notin A\n",
    "$$\n",
    "Esta idea de pertenencia nos permite simplificar las expresiones de definición intensiva de un conjunto. Por ejemplo, si $F$ es el conjunto de cartas de la baraja francesa, definimos el conjunto $C$ anterior como:\n",
    "$$\n",
    "C = \\{(v, p):(v,p)\\in F\\land p\\in\\{c, d\\}\\}\n",
    "$$\n",
    "el símbolo $\\land$ representa el operador *and* lógico en matemáticas y las variables $v$ y $p$ representan el valor y el palo de la carta respectivamente. También resulta más sencillo definir el conjunto $I$ anterior:\n",
    "$$\n",
    "I = \\{a+1:a\\in A\\}\n",
    "$$\n",
    "o el conjunto $E^2$:\n",
    "$$\n",
    "E^2=\\{e^2:e\\in E\\land e \\equiv 0 \\pmod{2}\\}\n",
    "$$\n",
    "En Python usaremos el operador `in` o `not in`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Comprobamos si 2 pertenece a A\n",
    "2 in A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comprobamos si 0 pertenece a A\n",
    "0 in A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 not in A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{True, 'Lorca', 'martes', -73, ('on', 'off')}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Comprobamos si 'on' pertenece a B\n",
    "print(B)\n",
    "'on' in B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando se habla de pertenencia hay que saber que los elementos de un conjunto pueden ser estructuras matemáticas como las tuplas, pero los elementos que conforman dicha tupla no son elementos del conjunto sino la tupla en sí (como nos ha ocurrido en el ejemplo anterior con el conjunto $B$)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Veamos que la tupla ('on', 'off') sí es elemento de B\n",
    "('on', 'off') in B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Veamos que la tupla ('off', 'on') no es elemento de B porque importa el orden\n",
    "('off', 'on') not in B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.- Comparación de conjuntos\n",
    "Como hemos visto anteriormente, la forma de saber si dos conjuntos son el mismo es si contienen exactamente los mismos elementos. Para compararlos en Python utilizamos el operador `==`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Comparamos el conjunto A con el conjunto B\n",
    "A == B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para verificar si dos conjuntos son distintos podemos usar el operador `!=`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Verificamos que A y B son distintos\n",
    "A != B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#También podemos negar la comparación de igualdad\n",
    "not(A == B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, los operadores de comparación `<`, `<=` y similares, no tienen mucho sentido entre dos conjuntos distintos, ya que, como ocurre con A y B, podrían contener elementos que ni siquiera son del mismo tipo o pertenecen al mismo universo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A < B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No obstante, vemos que Python sí nos devuelve un resultado de la operación. Veremos la razón en la siguiente sección."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> Supóngase que en Python no existen los operadores de comparación entre conjuntos vistos en esta sección y desarrolla una función <i>soniguales(A, B)</i> que compare los conjuntos A y B que se le pasan por parámetros. Solo se puede utilizar lo visto en clase.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "Todos los elementos del primer conjunto están en el segundo\n",
      "False\n",
      "Todos los elementos del primer conjunto están en el segundo\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def soniguales(A, B):\n",
    "    #Verificamos primero que todos los elementos de A están en B\n",
    "    for a in A:\n",
    "        if a not in B:\n",
    "            return False\n",
    "    print('Todos los elementos del primer conjunto están en el segundo')\n",
    "    #A continuación es necesario verificar que todos los elementos de B están en A\n",
    "    for b in B:\n",
    "        if b not in A:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "print(soniguales(A, B))\n",
    "print(soniguales({1,2}, A))\n",
    "print(soniguales(A, {3,2,1}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height: 2px; background-color: #858585;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.- Subconjuntos\n",
    "Puede ocurrir que un conjunto no contenga los mismos elementos que otro, pero que todos sus elementos sí están en otro. Por ejemplo, todos los elementos de $A=\\{1,2,3\\}$ se encuentran en el conjunto $E=\\{1,2,3,4\\}$, pero no al revés (por lo que no son iguales). Se dirá entonces que $A$ es un subconjunto de $E$. Por lo tanto, si se tienen dos conjuntos $C_1$ y $C_2$, diremos que $C_1$ es subconjunto de $C_2$ si cada elemento de $C_1$ es, a su vez, un elemento de $C_2$. También se dice que  $C_2$ es un superconjunto de $C_1$.\n",
    "\n",
    "<img src=\"./images/subset.png\">\n",
    "\n",
    "Matemáticamente escribiremos $C_1 \\subseteq C_2$ o $C_2 \\supseteq C_1$ y diremos que $C_1$ está contenido en $C_2$ o que $C_2$ contiene a $C_1$. Python ofrece al menos dos posibilidades para verificar la relación de subconjunto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Comprobamos que A es subconjunto de E\n",
    "A.issubset(E)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Podemos comprobar que E es superconjunto de A\n",
    "E.issuperset(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Comprobamos que A es subconjunto de E\n",
    "A < E"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dado un conjunto $C_1$ existen dos tipos de subconjuntos:\n",
    "- **Propios**: aquellos que son subconjuntos y poseen al menos un elemento pero no todos los elementos de $C_1$. Por ejemplo $A$ es un subconjunto impropio de $E$ y se escribirá $A\\subset E$.\n",
    "- **Impropios**: estos son el conjunto vacío y el propio $C_1$ y se escribe $\\emptyset\\subset C_1$ y $C_1\\subseteq C_1$ (esta última se lee que $C1$ contiene o es igual que $C_1$).\n",
    "Para distinguir entre $\\subset$ y $\\subseteq$ en Python utilizamos los operadores `<` y `<=`, respectivamente. Así se tiene que:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E < E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "E <= E"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set() < E"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gracias a la relación de subconjuntos, podemos decir que dos conjuntos $C_1$ y $C_2$ serán iguales cuando $C_1\\subseteq C_2$ y $C_2\\subseteq C_1$. De esta forma podemos simplificar la función *soniguales* del último ejercicio de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#Simplificamos la función son iguales utilizando lo visto de subconjuntos\n",
    "def sonigualessimple(A,B):\n",
    "    return A <= B and B <= A\n",
    "print(sonigualessimple(A, B))\n",
    "print(sonigualessimple({1,2}, A))\n",
    "print(sonigualessimple(A, {3,2,1}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.- Operaciones de conjuntos\n",
    "### 3.1.- Cardinalidad\n",
    "Como se vio en la introducción, un conjunto puede tener un número finito o infinito de elementos. En caso de que sea finito, es posible contar los elementos de dicho conjunto. La cardinalidad de un conjunto finito $S$, representada matemáticamente como $\\lvert S\\rvert$, $\\text{card}(S)$ o $\\text{#}S$, es el número de elementos de $S$. Por ejemplo, $\\lvert A\\rvert=\\lvert \\{1,2,3\\}\\rvert=3$, mientras que $\\lvert B\\rvert=5$. En Python usamos la función `len`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculamos la cardinalidad de A\n",
    "len(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculamos la cardinalidad de B\n",
    "len(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculamos la cardinalidad del conjunto vacío\n",
    "len(set())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen ciertas propiedades de cardinalidad que son fácilmente deducibles:\n",
    "- $\\lvert\\emptyset\\rvert=0$\n",
    "- $C_1=C_2\\Rightarrow \\lvert C_1\\rvert = \\lvert C_2\\rvert$\n",
    "- $C_1\\subseteq C_2\\Rightarrow \\lvert C_1\\rvert\\leq\\lvert C_2\\rvert$\n",
    "\n",
    "### 3.2.- Partes de un conjunto\n",
    "Dado un conjunto cualquiera $C_1$, las partes de $C_1$ o el conjunto potencia de $C_1$, que se denota por $\\mathcal{P}(C_1)$ es el conjunto que viene definido por:\n",
    "$$\n",
    "\\mathcal{P}(C_1) = \\{C_2:C_2\\subset C_1\\}\n",
    "$$\n",
    "Es decir, las partes de $C_1$ es el conjunto conformado por todos los subconjuntos que pueden construirse a partir de $C_1$ (incluido los impropios). Por ejemplo, si recordamos que $A=\\{1,2,3\\}$ entonces tendremos que:\n",
    "$$\n",
    "\\mathcal{P}(A) = \\{\\emptyset, \\{1\\}, \\{2\\}, \\{3\\}, \\{1,2\\}, \\{1,3\\},\\{2,3\\}\\{1,2,3\\}\\}\n",
    "$$\n",
    "El conjunto potencia se caracteriza por las siguientes propiedades que se cumplen para cualquier conjunto $S$:\n",
    "- $\\emptyset\\in\\mathcal{P}(S)$\n",
    "- $S\\in\\mathcal{P}(S)$\n",
    "- $\\lvert\\mathcal{P}(S)\\rvert=2^{\\lvert S\\rvert}$\n",
    "- $\\mathcal{P}(\\emptyset)=\\{\\emptyset\\}$\n",
    "\n",
    "### 3.3.- Métodos de set()\n",
    "Aunque matemáticamente no sea necesario definir operaciones para modificar un conjunto, en Python contamos con una serie de métodos de la clase `set` que nos permite trabajar más fácilmente con ellos, ya que dicha clase es mutable (es decir, podemos modificar, eliminar o añadir nuevos elementos):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#El método add añade un elemento al conjunto\n",
    "S = {1,2,3,4}\n",
    "S.add(5)\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Si volvemos a añadir un elemento ya existente no cambiará el conjunto\n",
    "S.add(5)\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#El método clear borra todos los elementos de un conjunto\n",
    "S.clear()\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#El método discard elimina el elemento\n",
    "S = {1,2,3,4,5}\n",
    "S.discard(5)\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#No lanzará un error si se trata de eliminar un elemento que no pertenece al conjunto\n",
    "S.discard(5)\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#El método pop eliminará un elemento al azar del conjunto\n",
    "S.pop()\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#El método remove elimina el elemento dado\n",
    "S.remove(2)\n",
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "2",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-53-ae7234ef9da1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#A diferencia de discard, sí lanzará un error si se trata de borrar un elemento inexistente\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mS\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 2"
     ]
    }
   ],
   "source": [
    "#A diferencia de discard, sí lanzará un error si se trata de borrar un elemento inexistente\n",
    "S.remove(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'apple', 'banana', 'cherry', 'google', 'microsoft'}"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#El método update inserta los elementos del conjunto como parámetro en el conjunto inicial\n",
    "#Insertamos los elementos de Y en el conjunto X\n",
    "X = {\"apple\", \"banana\", \"cherry\"}\n",
    "Y = {\"google\", \"microsoft\", \"apple\"}\n",
    "\n",
    "X.update(Y)\n",
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4.- Unión de conjuntos\n",
    "Sean $C_1$ y $C_2$ dos conjuntos cualesquiera, entonces la unión de ellos, representado por $C_1\\cup C_2$ es el conjunto de todos los elementos que pertenecen a uno de los dos conjuntos.\n",
    "\n",
    "<img src=\"./images/union.png\">\n",
    "\n",
    "Matemáticamente, escribiremos la unión como:\n",
    "$$\n",
    "C_1\\cup C_2 = \\{x:x\\in C_1\\lor x\\in C_2\\}\n",
    "$$\n",
    "donde $\\lor$ es el operador lógico *or*. Implementémoslo en Python:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "    <b>Ejercicio:</b> Desarrolla una función <i>union(A,B)</i> que devuelva el conjunto unión de los dos conjuntos que recibe por parámetros sin utilizar el método <i>update</i>.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def union(A, B):\n",
    "    result = set()\n",
    "    for a in A:\n",
    "        result.add(a)\n",
    "    for b in B:\n",
    "        result.add(b)\n",
    "    return result\n",
    "\n",
    "union({1,2,3}, {3, 4, 5})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr style=\"height: 2px; background-color: #858585;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo, no es necesario definir nuestra propia función unión ni utilizar el método *update*, en Python existen dos maneras de calcular la unión de dos conjuntos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{('on', 'off'), -73, 1, 2, 3, 'Lorca', 'martes'}"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Utilizando el operador |\n",
    "A | B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 'Lorca', 'martes', -73, ('on', 'off')}\n",
      "{True, 2, 3, -73, 'Lorca', 'martes', ('on', 'off')}\n"
     ]
    }
   ],
   "source": [
    "#Utilizando el método union\n",
    "print(A.union(B))\n",
    "print(B.union(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el caso de la unión, parece razonable obtener el mismo resultado independientemente del orden de los conjuntos.\n",
    "\n",
    "### 3.5.- Intersección de conjuntos\n",
    "Sean $C_1$ y $C_2$ dos conjuntos cualesquiera, entonces la intersección de ellos, representado por $C_1\\cap C_2$ es el conjunto de todos los elementos que comparten ambos conjuntos, es decir los elementos que pertenecen a los dos conjuntos dados.\n",
    "\n",
    "<img src=\"./images/intersection.png\">\n",
    "\n",
    "Matemáticamente, escribiremos la intersección como:\n",
    "$$\n",
    "C_1\\cap C_2 = \\{x:x\\in C_1\\land x\\in C_2\\}\n",
    "$$\n",
    "En Python hay dos maneras de calcular la intersección de dos conjuntos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Utilizando el operador &\n",
    "S1 = {1,2,3,4}\n",
    "S2 = {2,3,0,-1}\n",
    "\n",
    "S1 & S2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Utilizando el método intersection\n",
    "S1.intersection(S2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que con la unión, el orden de laintersección de conjuntos no afecta al resultado final. Gracias a la unión y a la intersección podemos enunciar la siguiente propiedad relacionada con la cardinalidad de conjuntos que se cumple para cualquier par de conjuntos $C_1$ y $C_2$:\n",
    "$$\n",
    "\\lvert C_1\\cup C_2\\rvert= \\lvert C_1\\rvert + \\lvert C_2\\rvert - \\lvert C_1\\cap C_2\\rvert\n",
    "$$\n",
    "Cuando $C_1\\cap C_2=\\emptyset$, es decir, no comparten ningún elemento, se dice que $C_1$ y $C_2$ son **conjuntos disjuntos**. En Python existe un método que nos permite saber cuándo dos conjuntos son disjuntos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Método isdisjoint\n",
    "A.isdisjoint(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.6.- Propiedades de la unión y la intersección\n",
    "\n",
    "Sean A,B y C subconjuntos cualesquiera de un conjunto universal E, se tiene:  \n",
    "\n",
    "1. **Uniforme**  \n",
    "> Dados A y B, tanto A $\\cup$ B como A $\\cap$ B existen y son únicos\n",
    "2. **Conmutativas**  \n",
    "> A $\\cup$ B=B $\\cup$ A  \n",
    "> A $\\cap$ B=B $\\cap$ A \n",
    "3. **Asociativas**  \n",
    "> A $\\cup$ (B $\\cup$ C) = (A $\\cup$ B) $\\cup$ C  \n",
    "> A $\\cap$ (B $\\cap$ C) = (A $\\cap$ B) $\\cap$ C  \n",
    "4. **Idempotencia**  \n",
    "> A $\\cup$ A = A  \n",
    "> A $\\cap$ A = A  \n",
    "5. **Elemento neutro**  \n",
    "> A $\\cup$ $\\varnothing$ = A  \n",
    "> A $\\cap$ E = A  \n",
    "6. **Absorción**  \n",
    "> A $\\cup$ (A $\\cap$ B) = A  \n",
    "> A $\\cap$ (A $\\cup$ B) = A\n",
    "7. **Distributivas**  \n",
    "> A $\\cup$ (B $\\cap$ C) = (A $\\cup$ B) $\\cap$ (A $\\cup$ C)  \n",
    "> A $\\cap$ (B $\\cup$ C) = (A $\\cap$ B) $\\cup$ (A $\\cap$ C)  \n",
    "\n",
    "### 3.7.- Diferencia de conjuntos\n",
    "Sean $C_1$ y $C_2$ dos conjuntos cualesquiera, entonces la diferencia de $C_1$ con $C_2$, representado por $C_1\\setminus C_2$ es el conjunto que resulta de eliminar de $C_1$ cualquier elemento que estén en $C_2$.\n",
    "\n",
    "<img src=\"./images/diferencia.png\">\n",
    "\n",
    "Matemáticamente, escribiremos la diferencia como:\n",
    "$$\n",
    "C_1\\setminus C_2 = \\{x:x\\in C_1\\land x\\notin C_2\\}\n",
    "$$\n",
    "En Python podemos calcular la diferencia de las siguientes formas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 3, 4}"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculamos la diferencia de conjuntos usando -\n",
    "{1,2,3,4} - {1, 5, 6, 7}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n",
      "{0, 2, 3, -1}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1, 4}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Calculamos la diferencia de conjuntos usando difference\n",
    "print(S1)\n",
    "print(S2)\n",
    "S1.difference(S2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.8.- Conjunto complementario\n",
    "Si tomamos un conjunto $U$ como conjunto universal (asumimos que no hay más elementos que los que pertenecen a U), y sea $C_1$ un subconjuntos cualquiera de $U$, entonces el conjunto complementario de $C_1$, representado por $C_1^c$ o $\\overline{C_1}$ es el conjunto que de todos los elementos de $U$ que no pertenecen a $C_1$.\n",
    "\n",
    "<img src=\"./images/complemento.png\">\n",
    "\n",
    "Matemáticamente, escribiremos el complementario como:\n",
    "$$\n",
    "\\overline{C_1} = \\{x:x\\in U\\land x\\notin C_1\\}\n",
    "$$\n",
    "En Python podemos calcular el complementario utilizando la diferencia de conjuntos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{5, 6, 7, 8, 9}"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U = {1,2,3,4,5,6,7,8,9}\n",
    "S = {1,2,3,4}\n",
    "\n",
    "S_comp = U - S\n",
    "S_comp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.9.- Diferencia simétrica de conjuntos\n",
    "Sean $C_1$ y $C_2$ dos conjuntos cualesquiera, entonces la diferencia simétrica de $C_1$ con $C_2$, representado por $C_1\\triangle C_2$ es el conjunto de todos los elementos que pertenence o bien a $C_1$, o bien a $C_2$, pero no a ambos.\n",
    "\n",
    "<img src=\"./images/diferenciasim.png\">\n",
    "\n",
    "Matemáticamente, escribiremos la diferencia simétrica como:\n",
    "$$\n",
    "C_1\\triangle C_2 = \\{x:x\\in C_1\\setminus C_2\\lor x\\in C_2\\setminus C_1\\} = (C_1\\cup C_2)\\setminus(C_1\\cap C_2)\n",
    "$$\n",
    "En Python podemos calcular la diferencia de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n",
      "{0, 2, 3, -1}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{-1, 0, 1, 4}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(S1)\n",
    "print(S2)\n",
    "S1.symmetric_difference(S2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el caso de la diferencia simétrica, da igual el orden de los conjuntos, es decir, es conmutativa. Esta propiedad no la posee la diferencia de conjuntos.\n",
    "\n",
    "### 3.10.- Producto cartesiano de conjuntos\n",
    "Sean $C_1$ y $C_2$ dos conjuntos cualesquiera, entonces el producto cartesiano de $C_1$ con $C_2$, representado por $C_1\\times C_2$ es el conjunto de todos los pares ordenados (tuplas) posibles que se pueden formar con un elemento que pertenence a $C_1$ y el segundo perteneciente a $C_2$. Matemáticamente, escribiremos el producto cartesiano como:\n",
    "$$\n",
    "C_1\\times C_2 = \\{(x,y):x\\in C_1\\land y\\in C_2\\}\n",
    "$$\n",
    "Como puede observarse, el producto cartesiano no es conmutativo. Veamos un ejemplo:\n",
    "$$\n",
    "\\{1,a,0\\}\\times\\{2,b\\}=\\{(1,2), (1,b), (a,2), (a,b), (0, 2), (0,b)\\}\n",
    "$$\n",
    "En Python podemos calcular el producto cartesiano de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n",
      "{0, 2, 3, -1}\n",
      "{(2, -1), (1, 2), (3, -1), (4, 0), (4, 3), (4, -1), (2, 0), (1, -1), (4, 2), (3, 0), (2, 3), (3, 3), (2, 2), (1, 0), (3, 2), (1, 3)}\n"
     ]
    }
   ],
   "source": [
    "#Usamos la función product\n",
    "from itertools import product\n",
    "\n",
    "print(S1)\n",
    "print(S2)\n",
    "print(set(product(S1, S2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{(2, -1), (1, 2), (3, -1), (4, 0), (4, 3), (4, -1), (2, 0), (1, -1), (4, 2), (3, 0), (2, 3), (3, 3), (2, 2), (1, 0), (3, 2), (1, 3)}\n"
     ]
    }
   ],
   "source": [
    "#También podemos construirlo por comprensión\n",
    "print({(x, y) for x in S1 for y in S2})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La siguiente propiedad de cardinalidad es fácilmente deducible:\n",
    "$$\n",
    "\\lvert C_1\\times C_2\\rvert = \\lvert C_1\\rvert\\cdot\\lvert C_2\\rvert\n",
    "$$\n",
    "### 3.11.- Suma de los elementos de un conjunto\n",
    "Al igual que ocurre con listas, Python facilita el cálculo de la suma de todos los elementos de un conjunto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(S2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parece razonable, que es necesario que todos los elementos del conjunto sean de tipo numérico.\n",
    "\n",
    "## 4.- Representación gráfica de un conjunto\n",
    "En las operaciones de conjutnos anteriores hemos utilizado representaciones gráficas que nos han ayudado a la comprensión de dichas operaciones. Estos esquemas son conocidos como **diagramas de Venn**.\n",
    "\n",
    "<img src=\"./Images/diagrama_venn.png\" width=400 height=200>\n",
    "\n",
    "Construyámoslo en Python:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: matplotlib_venn in c:\\users\\cmore\\anaconda3\\lib\\site-packages (0.11.7)\n",
      "Requirement already satisfied: scipy in c:\\users\\cmore\\anaconda3\\lib\\site-packages (from matplotlib_venn) (1.6.2)\n",
      "Requirement already satisfied: matplotlib in c:\\users\\cmore\\anaconda3\\lib\\site-packages (from matplotlib_venn) (3.3.4)\n",
      "Requirement already satisfied: numpy in c:\\users\\cmore\\anaconda3\\lib\\site-packages (from matplotlib_venn) (1.20.1)\n",
      "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.3 in c:\\users\\cmore\\anaconda3\\lib\\site-packages (from matplotlib->matplotlib_venn) (2.4.7)\n",
      "Requirement already satisfied: cycler>=0.10 in c:\\users\\cmore\\anaconda3\\lib\\site-packages (from matplotlib->matplotlib_venn) (0.10.0)\n",
      "Requirement already satisfied: python-dateutil>=2.1 in c:\\users\\cmore\\anaconda3\\lib\\site-packages (from matplotlib->matplotlib_venn) (2.8.1)\n",
      "Requirement already satisfied: kiwisolver>=1.0.1 in c:\\users\\cmore\\anaconda3\\lib\\site-packages (from matplotlib->matplotlib_venn) (1.3.1)\n",
      "Requirement already satisfied: pillow>=6.2.0 in c:\\users\\cmore\\anaconda3\\lib\\site-packages (from matplotlib->matplotlib_venn) (8.2.0)\n",
      "Requirement already satisfied: six in c:\\users\\cmore\\anaconda3\\lib\\site-packages (from cycler>=0.10->matplotlib->matplotlib_venn) (1.15.0)\n"
     ]
    }
   ],
   "source": [
    "!pip install matplotlib_venn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from matplotlib_venn import venn2\n",
    "\n",
    "venn2([set(['A', 'B', 'C', 'D']), set(['D', 'E', 'F'])])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.- Ejemplos de conjuntos matemáticos\n",
    "Además de los ejemplos vistos y los que podamos diseñar mediante la observación y el análisis de todo lo que nos rodea, en matemáticas se han diseñado una serie de conjuntos que pueden ayudarnos a la hora de realizar operaciones y enfrentarnos a los problemas matemáticos. Estos conjuntos son:\n",
    "\n",
    "- Los **números naturales** ($\\mathbb{N}$): es el conjunto que posee todos los posibles valores de cardinalidad que podemos obtener. De esta forma se tiene que:\n",
    "$$\\mathbb{N}=\\{0,1,2,3,4,\\dots\\}$$\n",
    "- Los **número enteros** ($\\mathbb{Z}$): es el conjunto que contiene los números naturales y sus opuestos. Por lo tanto se tendrá que $\\mathbb{N}\\subset\\mathbb{Z}$. Surgen a partir de la necesidad de resolver la operación $m - n$ donde $m,n\\in\\mathbb{N}$ y $m<n$. De esta forma se tendrá que: \n",
    "$$\\mathbb{Z}=\\{\\dots, -4,-3,-2,-1,0,1,2,3,4,\\dots\\}=\\{-n:n\\in\\mathbb{N}^+\\}\\cup\\{0\\}\\cup\\mathbb{N}^+$$\n",
    "- Los **números racionales** ($\\mathbb{Q}$): es el conjunto de todos los números que pueden escribirse como $z/n$ donde $z\\in\\mathbb{Z}$ y $n\\in\\mathbb{N}^+$. Si se establece una relación de equivalencia adecuada, se afirmará que $\\mathbb{Z}\\subset\\mathbb{Q}$. Así se tiene que:\n",
    "$$\\mathbb{Q}=\\left\\{\\frac{z}{n}:z\\in\\mathbb{Z}\\land n\\in\\mathbb{N}^+\\right\\}$$\n",
    "- Los **número reales** ($\\mathbb{R}$): constituidos por todos los números racionales y aquellos números decimales que no pueden representarse mediante una fracción (como es el caso de $\\pi$). Por lo tanto $\\mathbb{Q}\\subset\\mathbb{R}$.\n",
    "\n",
    "Todos estos conjuntos son infinitos, por lo que no podremos implementarlos en Python (por cuestión de que el ordenador dispone de una memoria finita así como no disponemos de un tiempo infinito para generar dichos conjuntos). Sin embargo, podemos obtener subconjuntos bastante grandes de estos conjuntos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000001"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Creamos el conjunto de los naturales hasta el valor 1.000.000\n",
    "s = {x for x in range(1000001)}\n",
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2000001"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Creamos el conjunto de los enteros desde -1.000.000 hasta 1.000.000\n",
    "len(s|{-x for x in s})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1000000"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Generamos un conjunto de tamaño 1.000.000 de los racionales comprendidos entre 1 y 2\n",
    "import numpy as np\n",
    "len(set(np.linspace(1,2,1000000)))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}