R/clases/2_probabilidad/1_elementos_de_probabilidad.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notas para contenedor de docker:**\n",
    "\n",
    "Comando de docker para ejecución de la nota de forma local:\n",
    "\n",
    "nota: cambiar `dir_montar` por la ruta de directorio que se desea mapear a `/datos` dentro del contenedor de docker.\n",
    "\n",
    "```\n",
    "dir_montar=<ruta completa de mi máquina a mi directorio>#aquí colocar la ruta al directorio a montar, por ejemplo: \n",
    "#dir_montar=/Users/erick/midirectorio.\n",
    "```\n",
    "\n",
    "Ejecutar:\n",
    "\n",
    "```\n",
    "VERSION=<versión imagen de docker>\n",
    "docker run --rm -v $dir_montar:/datos --name jupyterlab_prope_r_kernel_tidyverse -p 8888:8888 -d palmoreck/jupyterlab_prope_r_kernel_tidyverse:$VERSION\n",
    "\n",
    "```\n",
    "\n",
    "Ir a `localhost:8888` y escribir el password para jupyterlab: `qwerty`\n",
    "\n",
    "\n",
    "Detener el contenedor de docker:\n",
    "\n",
    "```\n",
    "docker stop jupyterlab_prope_r_kernel_tidyverse\n",
    "```\n",
    "\n",
    "Documentación de la imagen de docker `palmoreck/jupyterlab_prope_r_kernel_tidyverse:<versión imagen de docker>` en [liga](https://github.com/palmoreck/dockerfiles/tree/master/jupyterlab/prope_r_kernel_tidyverse)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ejecución de la nota usar:\n",
    "\n",
    "[docker](https://www.docker.com/) (instalación de forma **local** con [Get docker](https://docs.docker.com/install/)) y ejecutar comandos que están al inicio de la nota de forma **local**. \n",
    "\n",
    "O bien dar click en alguno de los botones siguientes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/palmoreck/dockerfiles-for-binder/jupyterlab_prope_r_kernel_tidyverse?urlpath=lab/tree/Propedeutico/R/clases/2_probabilidad/1_elementos_de_probabilidad.ipynb) esta opción crea una máquina individual en un servidor de Google, clona el repositorio y permite la ejecución de los notebooks de jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Run on Repl.it](https://repl.it/badge/github/palmoreck/dummy)](https://repl.it/languages/Rlang) esta opción no clona el repositorio, no ejecuta los notebooks de jupyter pero permite ejecución de instrucciones de Python de forma colaborativa con [repl.it](https://repl.it/). Al dar click se crearán nuevos ***repl*** debajo de sus users de ***repl.it***.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lo siguiente está basado los libros:\n",
    "\n",
    "### * B. Rumbos, Pensando Antes de Actuar: Fundamentos de Elección Racional, 2009.\n",
    "\n",
    "### * G. J. Kerns, Introduction to Probability and Statistics Using R, 2014."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### El libro de G. J. Kerns tiene github: [jkerns/IPSUR](https://github.com/gjkerns/IPSUR)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notas:**\n",
    "\n",
    "* Se utilizará el paquete [prob](https://cran.r-project.org/web/packages/prob/index.html) de *R* para los experimentos descritos en la nota y aunque con funciones nativas de *R* se pueden crear los experimentos, se le da preferencia a mostrar cómo en *R* se tienen paquetes para muchas aplicaciones.\n",
    "\n",
    "* Cuidado al utilizar las funciones del paquete `prob` para construir espacios de probabilidad grandes como lanzar un dado 9 veces... (tal experimento tiene 10 millones de posibles resultados)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "options(repr.plot.width=4, repr.plot.height=4) #esta línea sólo se ejecuta para jupyterlab con R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Loading required package: combinat\n",
      "\n",
      "\n",
      "Attaching package: ‘combinat’\n",
      "\n",
      "\n",
      "The following object is masked from ‘package:utils’:\n",
      "\n",
      "    combn\n",
      "\n",
      "\n",
      "Loading required package: fAsianOptions\n",
      "\n",
      "Loading required package: timeDate\n",
      "\n",
      "Loading required package: timeSeries\n",
      "\n",
      "Loading required package: fBasics\n",
      "\n",
      "Loading required package: fOptions\n",
      "\n",
      "\n",
      "Attaching package: ‘prob’\n",
      "\n",
      "\n",
      "The following objects are masked from ‘package:base’:\n",
      "\n",
      "    intersect, setdiff, union\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "library(prob)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tipos de experimentos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se tienen dos tipos: **determinísticos y aleatorios**. Un **experimento determinístico** es aquel cuyo resultado puede ser predicho con seguridad antes de realizarlo, por ejemplo: combinar hidrógeno y oxígeno o sumar $2+3$. Un **experimento aleatorio** es aquel cuyo resultado está determinado por el **azar**, por esto **no es posible predecir su resultado antes de realizarlo**. Ejemplos de experimentos aleatorios se encuentran lanzar una moneda, lanzar un dado, lanzar un dardo a un tiro al blanco, número de semáforos de color rojo que te encontrarás al ir a casa, cuántas hormigas caminan por la acera de peatones en un tiempo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sesgo, independencia y justicia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decimos que un juego de azar es **justo u honesto** si sus resultados no presentan asimetría (aparecen con la misma frecuencia) y son **independientes** si no presentan patrón alguno. Tirar una moneda, un dado o girar una ruleta son **juegos justos** siempre y cuando no estén alterados de alguna manera."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejemplos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1) Supóngase que se lanza un oso de peluche al aire. El oso gira varias veces y cae al suelo de cuatro posibles maneras, panza abajo, panza arriba, sentado o de cabeza. Al lanzarlo 100 veces se obtiene el número de veces que cae de cada forma como se observa en la siguiente tabla:\n",
    "\n",
    "|resultado|panza abajo|panza arriba|sentado |de cabeza\n",
    "|:---------:|:-----------:|:------------:|:--------:|:---------:\n",
    "|# de veces| 54|40|5|1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Claramente se trata de resultados **asimétricos** ya que el oso cae panza abajo más de la mitad de las veces y sólo cae de cabeza uno de cada cien lanzamientos. Los resultados, sin embargo, **son independientes** pues si el oso cae en alguna posición, esto es irrelevante para el siguiente lanzamiento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2) Consideremos una urna con 25 canicas blancas, 25 rojas, 25 amarillas y 25 azules. Sacamos una canica de la urna y **observamos** que es amarilla. **Sin reemplazar** la canica amarilla en la urna tomamos otra canica (equivalente a haber sacado dos canicas). Claramente la urna ya no es la misma pues ahora contiene 25 canicas blancas, rojas y azules y 24 canicas amarillas. Nuestras expectativas para el color de la segunda canica **no son independientes** del resultado de haber tomado una canica amarilla inicialmente. Si la segunda canica es, por ejemplo roja, y **tampoco la reemplazamos**, entonces la urna contiene 25 canicas blancas y azules y 24 rojas y amarillas. Las expectativas para el color de la tercera canica cambian. En este ejemplo, los resultados de **sacar canicas de colores en sucesión y sin reemplazo no son independientes**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3) Consideremos la misma urna del ejemplo anterior. Observemos que si cada vez que **sacamos una canica y anotamos su color la reemplazamos nuevamente en la urna**, entonces el sacar la segunda canica **es independiente** de lo que hayamos hecho antes. La razón es que tenemos, esencialmente, **la misma urna inicial**. Aún mas, si se repite el experimento de extraer y anotar su color (con o sin reemplazo), entonces se le llama **muestreo ordenado** y si no se anota su color se le llama **muestreo no ordenado**, no tenemos idea en qué orden se eligieron las canicas, sólo observamos una o más canicas y no importa el orden en que se sacaron de acuerdo a lo que observamos y esto es equivalente a haber extraído las canicas y colocarlas en una bolsa antes de observar qué sacamos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación** \n",
    "\n",
    "Este modelo de la urna con canicas es utilizado con frecuencia ya que es sumamente práctico para ciertas abstracciones de la realidad y es considerado dentro de la clase de **experimentos generales** pues contiene a experimentos aleatorios más comunes. Por ejemplo, lanzar una moneda dos veces es equivalente a sacar dos canicas de una urna que están etiquetadas con águila y sol. Lanzar un dado es equivalente a sacar una canica de una urna con seis canicas etiquetadas del 1 al 6.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4) En un casino observamos que los últimos cinco resultados de la ruleta han sido los siguientes: 10 negro, 17 negro, 4 negro, 15 negro y 22 negro. Al observar esto escuchamos el consejo de un experimentado apostador: “ponga todo su dinero en el rojo pues ya toca que salga rojo”. Sabiamente no le hacemos caso. La razón es simple: **la ruleta no es una urna sin reemplazo sino más bien es una urna con reemplazo**. En cada giro, **cada número tiene la misma probabilidad de aparecer** y se trata de la misma ruleta. Cada giro es **independiente** de los demás por lo que **no hay un patrón definido** y los resultados previos no modifican la habilidad para predecir el resultado del siguiente giro."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Espacio de resultados o espacio muestral"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supongamos que una acción o experimento puede tener distintas consecuencias o resultados (*outcomes*) y sea $S = \\{r_1, r_2, \\dots, r_n\\}$ el conjunto de resultados posibles. A este conjunto se le conoce como **espacio de resultados o espacio muestral**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo, si lanzamos una moneda al aire el espacio muestral es *{águila, sol}* y al tirar un dado de seis caras el espacio muestral es $\\{1,2,3,4,5,6\\}$. Es importante notar que, en cada caso, los resultados son **mutuamente excluyentes**, es decir, **no pueden ocurrir simultáneamente**. Asimismo, **el espacio muestral comprende a todos los resultados posibles**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Cómo representar el espacio de resultados o espacio muestral en R?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos podemos apoyar de la estructura *data frame* la cual es una colección rectangular de variables. Cada renglón del *data frame* corresponde a un resultado del experimento (pero se verá más adelante que el *data frame* sólo nos ayudará a describir ciertos espacios de resultados de experimentos)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experimento: lanzar un oso de peluche al aire. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entonces el espacio muestral es:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "S = data.frame(cae=c(\"panza abajo\", \"panza arriba\", \"sentado\", \"de cabeza\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 4 × 1</caption>\n",
       "<thead>\n",
       "\t<tr><th scope=col>cae</th></tr>\n",
       "\t<tr><th scope=col>&lt;chr&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><td>panza abajo </td></tr>\n",
       "\t<tr><td>panza arriba</td></tr>\n",
       "\t<tr><td>sentado     </td></tr>\n",
       "\t<tr><td>de cabeza   </td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 4 × 1\n",
       "\\begin{tabular}{l}\n",
       " cae\\\\\n",
       " <chr>\\\\\n",
       "\\hline\n",
       "\t panza abajo \\\\\n",
       "\t panza arriba\\\\\n",
       "\t sentado     \\\\\n",
       "\t de cabeza   \\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 4 × 1\n",
       "\n",
       "| cae &lt;chr&gt; |\n",
       "|---|\n",
       "| panza abajo  |\n",
       "| panza arriba |\n",
       "| sentado      |\n",
       "| de cabeza    |\n",
       "\n"
      ],
      "text/plain": [
       "  cae         \n",
       "1 panza abajo \n",
       "2 panza arriba\n",
       "3 sentado     \n",
       "4 de cabeza   "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Experimento: sacar canicas de una urna."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supóngase que se tiene una urna con tres canicas con etiquetas $1, 2, 3$ respectivamente. Se sacarán $2$ canicas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Cómo realizar el experimento en R? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el paquete [prob](https://cran.r-project.org/web/packages/prob/index.html) se tiene la función [urnsamples](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/urnsamples) la cual tiene argumentos `x, size, replace, ordered`. El argumento `x` representa la urna de la cual se realizará el muestreo, `size` representa el tamaño de la muestra, `replace` y `ordered` son argumentos lógicos y especifican cómo se debe realizar el muestreo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Con reemplazo y orden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como el experimento es con reemplazo se pueden sacar cualquiera de las canicas $1, 2, 3$ en cualquier extracción, además como es con orden **se llevará un registro del orden de las extracciones** que se realizan. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  X1 X2\n",
      "1  1  1\n",
      "2  2  1\n",
      "3  3  1\n",
      "4  1  2\n",
      "5  2  2\n",
      "6  3  2\n",
      "7  1  3\n",
      "8  2  3\n",
      "9  3  3\n"
     ]
    }
   ],
   "source": [
    "print(urnsamples(1:3, size = 2, replace = TRUE, ordered = TRUE)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La primer columna con etiqueta $X1$ representa la primera extracción y el primer renglón representa una realización del experimento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observaciones** \n",
    "\n",
    "* Obsérvese que los renglones $2$ y $4$ son idénticos salvo el orden en el que se muestran los números.\n",
    "\n",
    "* Este experimento **es equivalente a** lanzar dos veces un dado de tres lados. Lo anterior se realiza en $R$ con:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  X1 X2\n",
      "1  1  1\n",
      "2  2  1\n",
      "3  3  1\n",
      "4  1  2\n",
      "5  2  2\n",
      "6  3  2\n",
      "7  1  3\n",
      "8  2  3\n",
      "9  3  3\n"
     ]
    }
   ],
   "source": [
    "print(rolldie(2, nsides = 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ver [rolldie](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/rolldie)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sin reemplazo y orden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como es sin reemplazo no observaremos en uno de los renglones $1, 1$ por ejemplo (mismo número en un renglón) y como es con orden se tendrán renglones de la forma $2, 1$ y $1, 2$ (pues se consideran distintos)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  X1 X2\n",
      "1  1  2\n",
      "2  2  1\n",
      "3  1  3\n",
      "4  3  1\n",
      "5  2  3\n",
      "6  3  2\n"
     ]
    }
   ],
   "source": [
    "print(urnsamples(1:3, size=2, replace = F, order = T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación** \n",
    "\n",
    "Obsérvese que hay menos renglones en este caso debido al procedimiento más restrictivo de muestreo. Si los números $1, 2, 3$ representaran \"Alicia\", \"Ana\" y \"Paulina\" respectivamente entonces este experimento sería **equivalente a** seleccionar dos personas de tres para que fueran la presidenta y vice-presidenta respectivamente de alguna compañía. El *data frame* anterior representa todas las posibilidades en que esto podría hacerse.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sin reemplazo y sin orden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nuevamente no observaremos en uno de los renglones $1, 1$ por ejemplo (mismo número en un renglón) y como es sin orden tendremos menos renglones que el caso anterior pues al sacar las canicas no se tendrán duplicados de extracciones anteriores no importando el orden de los números."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  X1 X2\n",
      "1  1  2\n",
      "2  1  3\n",
      "3  2  3\n"
     ]
    }
   ],
   "source": [
    "print(urnsamples(1:3, size=2, replace = F, order = F))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este experimento es **equivalente a** ir a donde está la urna, mirar en ella y elegir un par de canicas. Este es el default de la función `urnsamples`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  X1 X2\n",
      "1  1  2\n",
      "2  1  3\n",
      "3  2  3\n"
     ]
    }
   ],
   "source": [
    "print(urnsamples(1:3,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Con reemplazo y sin orden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se reemplazan las canicas en cada extracción pero no se \"recuerda\" el orden en el que fueron extraídas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  X1 X2\n",
      "1  1  1\n",
      "2  1  2\n",
      "3  1  3\n",
      "4  2  2\n",
      "5  2  3\n",
      "6  3  3\n"
     ]
    }
   ],
   "source": [
    "print(urnsamples(1:3, size = 2, replace = T, order = F))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este experimento es **equivalente a**:\n",
    " * Tener una taza en el que agitamos dos dados de tres caras y nos acercamos a ver la taza.\n",
    " * Los resultados de distribuir dos pelotas idénticas de golf en tres cajas etiquetadas con 1, 2 y 3."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Notas respecto a la función `urnsamples`** \n",
    "\n",
    "* La urna no necesita tener números, esto es, se podría haber definido un vector $x$ como `x = c('Roja', 'Azul', 'Amarilla')`.\n",
    "* Los elementos que contiene la urna siempre son distinguibles para la función `urnsamples`. Entonces situaciones como `x = c('Roja', 'Roja', 'Azul')` no se sugieren ejecutar pues el resultado puede **no ser correcto** (por ejemplo, realizar un experimento en el que se tienen canicas no distinguibles resultan renglones del *data frame* como si se hubiera usado `ordered=T` aún si se eligió `ordered=F`. Enunciados similares aplican para el argumento `replace`).\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eventos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un evento $E$ es una colección de resultados del experimento, un subconjunto del espacio muestral "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación** \n",
    "\n",
    "El conjunto vacío, $\\emptyset$, es un evento pues es subconjunto de todo conjunto y en el contexto de eventos representa un evento sin espacio de resultados.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bajo la notación de $S = \\{r_1, r_2, \\dots, r_n\\}$ como el espacio muestral, todos los eventos posibles son: $\\emptyset , \\{r_1\\}, \\{r_2\\}, \\dots, \\{r_1, r_2\\}, \\{r_1, r_3\\}, \\dots \\{r_2, r_3\\}, \\dots \\{r_{n-1}, r_n\\}, \\dots \\{r_1, r_2, \\dots , r_n\\}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ocurrencia de un evento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decimos que el evento $E$ ocurrió si el resultado de un experimento pertenece a $E$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo usual es que los eventos se refieran a resultados con alguna característica de interés, por ejemplo, si lanzamos dos dados podrían interesarnos todas las parejas de números cuya suma sea mayor a cinco. Si se trata de una población de individuos, podríamos querer saber algo acerca de todos los que tienen cierto nivel de ingreso, o los que adquieren cierto nivel educativo o los que tuvieron sarampion de niños, etcétera."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Eventos mutuamente excluyentes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decimos que los eventos $E_1, E_2, \\dots$ son mutuamente excluyentes o ajenos si $E_i \\cap E_j = \\emptyset$ $\\forall E_i \\neq E_j$ (sólo ocurre exactamente uno de ellos)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación** \n",
    "\n",
    "Como los eventos son subconjuntos es permitido realizar operaciones típicas de conjuntos, en la definición anterior se usó la intersección $\\cap$ y $E_i \\cap E_j$ consiste de todos los resultados comunes a $E_i$ y $E_j$.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo, en el caso del lanzamiento de una moneda, los eventos $E_1=\\{\\text{obtener águila}\\}$ y $E_2 = \\{\\text{obtener sol}\\}$ son mutuamente excluyentes y en el caso de $E_1 = \\{\\text{hoy día soleado}\\}$, $E_2 = \\{\\text{hoy día nublado} \\}$ no son mutuamente excluyentes pues tenemos días que son nublados y soleados."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1) Lanzamiento de una moneda un número de veces definido (o lanzamiento de monedas distintas)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "S <- tosscoin(2, makespace = TRUE) #one coin, two tosses\n",
    "                                   #equivalently tossing two distinct coins"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 4 × 3</caption>\n",
       "<thead>\n",
       "\t<tr><th scope=col>toss1</th><th scope=col>toss2</th><th scope=col>probs</th></tr>\n",
       "\t<tr><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;dbl&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><td>H</td><td>H</td><td>0.25</td></tr>\n",
       "\t<tr><td>T</td><td>H</td><td>0.25</td></tr>\n",
       "\t<tr><td>H</td><td>T</td><td>0.25</td></tr>\n",
       "\t<tr><td>T</td><td>T</td><td>0.25</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 4 × 3\n",
       "\\begin{tabular}{lll}\n",
       " toss1 & toss2 & probs\\\\\n",
       " <fct> & <fct> & <dbl>\\\\\n",
       "\\hline\n",
       "\t H & H & 0.25\\\\\n",
       "\t T & H & 0.25\\\\\n",
       "\t H & T & 0.25\\\\\n",
       "\t T & T & 0.25\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 4 × 3\n",
       "\n",
       "| toss1 &lt;fct&gt; | toss2 &lt;fct&gt; | probs &lt;dbl&gt; |\n",
       "|---|---|---|\n",
       "| H | H | 0.25 |\n",
       "| T | H | 0.25 |\n",
       "| H | T | 0.25 |\n",
       "| T | T | 0.25 |\n",
       "\n"
      ],
      "text/plain": [
       "  toss1 toss2 probs\n",
       "1 H     H     0.25 \n",
       "2 T     H     0.25 \n",
       "3 H     T     0.25 \n",
       "4 T     T     0.25 "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  toss1 toss2 probs\n",
      "1     H     H  0.25\n",
      "2     T     H  0.25\n",
      "3     H     T  0.25\n"
     ]
    }
   ],
   "source": [
    "print(S[1:3, ]) #example of three events consisting each one of \n",
    "                #each row of S"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  toss1 toss2 probs\n",
      "2     T     H  0.25\n",
      "4     T     T  0.25\n"
     ]
    }
   ],
   "source": [
    "print(S[c(2,4), ]) #example of two events consisting each one of\n",
    "                   #each row of S"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ver [tosscoin](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/tosscoin)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2) Baraja**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "S<-cards()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 6 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th></th><th scope=col>rank</th><th scope=col>suit</th></tr>\n",
       "\t<tr><th></th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;fct&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><th scope=row>1</th><td>2</td><td>Club</td></tr>\n",
       "\t<tr><th scope=row>2</th><td>3</td><td>Club</td></tr>\n",
       "\t<tr><th scope=row>3</th><td>4</td><td>Club</td></tr>\n",
       "\t<tr><th scope=row>4</th><td>5</td><td>Club</td></tr>\n",
       "\t<tr><th scope=row>5</th><td>6</td><td>Club</td></tr>\n",
       "\t<tr><th scope=row>6</th><td>7</td><td>Club</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 6 × 2\n",
       "\\begin{tabular}{r|ll}\n",
       "  & rank & suit\\\\\n",
       "  & <fct> & <fct>\\\\\n",
       "\\hline\n",
       "\t1 & 2 & Club\\\\\n",
       "\t2 & 3 & Club\\\\\n",
       "\t3 & 4 & Club\\\\\n",
       "\t4 & 5 & Club\\\\\n",
       "\t5 & 6 & Club\\\\\n",
       "\t6 & 7 & Club\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 6 × 2\n",
       "\n",
       "| <!--/--> | rank &lt;fct&gt; | suit &lt;fct&gt; |\n",
       "|---|---|---|\n",
       "| 1 | 2 | Club |\n",
       "| 2 | 3 | Club |\n",
       "| 3 | 4 | Club |\n",
       "| 4 | 5 | Club |\n",
       "| 5 | 6 | Club |\n",
       "| 6 | 7 | Club |\n",
       "\n"
      ],
      "text/plain": [
       "  rank suit\n",
       "1 2    Club\n",
       "2 3    Club\n",
       "3 4    Club\n",
       "4 5    Club\n",
       "5 6    Club\n",
       "6 7    Club"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head(S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 6 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th></th><th scope=col>rank</th><th scope=col>suit</th></tr>\n",
       "\t<tr><th></th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;fct&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><th scope=row>47</th><td>9 </td><td>Spade</td></tr>\n",
       "\t<tr><th scope=row>48</th><td>10</td><td>Spade</td></tr>\n",
       "\t<tr><th scope=row>49</th><td>J </td><td>Spade</td></tr>\n",
       "\t<tr><th scope=row>50</th><td>Q </td><td>Spade</td></tr>\n",
       "\t<tr><th scope=row>51</th><td>K </td><td>Spade</td></tr>\n",
       "\t<tr><th scope=row>52</th><td>A </td><td>Spade</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 6 × 2\n",
       "\\begin{tabular}{r|ll}\n",
       "  & rank & suit\\\\\n",
       "  & <fct> & <fct>\\\\\n",
       "\\hline\n",
       "\t47 & 9  & Spade\\\\\n",
       "\t48 & 10 & Spade\\\\\n",
       "\t49 & J  & Spade\\\\\n",
       "\t50 & Q  & Spade\\\\\n",
       "\t51 & K  & Spade\\\\\n",
       "\t52 & A  & Spade\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 6 × 2\n",
       "\n",
       "| <!--/--> | rank &lt;fct&gt; | suit &lt;fct&gt; |\n",
       "|---|---|---|\n",
       "| 47 | 9  | Spade |\n",
       "| 48 | 10 | Spade |\n",
       "| 49 | J  | Spade |\n",
       "| 50 | Q  | Spade |\n",
       "| 51 | K  | Spade |\n",
       "| 52 | A  | Spade |\n",
       "\n"
      ],
      "text/plain": [
       "   rank suit \n",
       "47 9    Spade\n",
       "48 10   Spade\n",
       "49 J    Spade\n",
       "50 Q    Spade\n",
       "51 K    Spade\n",
       "52 A    Spade"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tail(S)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A continuación se muestran eventos extraídos del espacio muestral que satisfacen una expresión lógica\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   rank  suit\n",
      "27    2 Heart\n",
      "28    3 Heart\n",
      "29    4 Heart\n",
      "30    5 Heart\n",
      "31    6 Heart\n",
      "32    7 Heart\n",
      "33    8 Heart\n",
      "34    9 Heart\n",
      "35   10 Heart\n",
      "36    J Heart\n",
      "37    Q Heart\n",
      "38    K Heart\n",
      "39    A Heart\n"
     ]
    }
   ],
   "source": [
    "print(subset(S, suit == 'Heart'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ver [cards](https://www.rdocumentation.org/packages/prob/versions/0.9-1/topics/cards)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función %in% checa si cada elemento de un vector está contenido en algún lugar de otro, en el siguiente caso se checa para cada renglón de la columna rank de S que se encuentre en el vector `c(7,8,9)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   rank    suit\n",
      "6     7    Club\n",
      "7     8    Club\n",
      "8     9    Club\n",
      "19    7 Diamond\n",
      "20    8 Diamond\n",
      "21    9 Diamond\n",
      "32    7   Heart\n",
      "33    8   Heart\n",
      "34    9   Heart\n",
      "45    7   Spade\n",
      "46    8   Spade\n",
      "47    9   Spade\n"
     ]
    }
   ],
   "source": [
    "print(subset(S, rank %in% 7:9)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3) Lanzamiento de un dado tres veces (o lanzamiento de tres dados distintos)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obsérvese que para la función `rolldie` también son aceptadas expresiones matemáticas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    X1 X2 X3\n",
      "180  6  6  5\n",
      "210  6  5  6\n",
      "215  5  6  6\n",
      "216  6  6  6\n"
     ]
    }
   ],
   "source": [
    "print(subset(rolldie(3), X1+X2+X3 > 16)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4) Lanzamiento de un dado cuatro veces (o lanzamiento de cuatro dados distintos)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función [isin](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/isin) checa que todo el vector `c(2,2,6)` esté en cada renglón del data.frame `S`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     X1 X2 X3 X4\n",
      "188   2  2  6  1\n",
      "404   2  2  6  2\n",
      "620   2  2  6  3\n",
      "836   2  2  6  4\n",
      "1052  2  2  6  5\n",
      "1088  2  2  1  6\n",
      "1118  2  1  2  6\n",
      "1123  1  2  2  6\n",
      "1124  2  2  2  6\n",
      "1125  3  2  2  6\n",
      "1126  4  2  2  6\n",
      "1127  5  2  2  6\n",
      "1128  6  2  2  6\n",
      "1130  2  3  2  6\n",
      "1136  2  4  2  6\n",
      "1142  2  5  2  6\n",
      "1148  2  6  2  6\n",
      "1160  2  2  3  6\n",
      "1196  2  2  4  6\n",
      "1232  2  2  5  6\n",
      "1268  2  2  6  6\n"
     ]
    }
   ],
   "source": [
    "S <- rolldie(4)\n",
    "print(subset(S, isin(S, c(2,2,6), ordered = TRUE))) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Nota** \n",
    "\n",
    "Otras funciones del paquete `prob` útiles para encontrar espacios muestrales son: [countrep](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/countrep) e [isrep](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/isrep).\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observación** \n",
    "\n",
    "Obsérvese que `%in%` e `%isin%` no realizan lo mismo.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "x <- 1:10\n",
    "y <- c(3,3,7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La siguiente línea checa que el 3 esté en x, que el 3 esté en x y que el 7 esté en x y devuelve el valor lógico de los tres chequeos, en este caso `all(c(T,T,T))`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "TRUE"
      ],
      "text/latex": [
       "TRUE"
      ],
      "text/markdown": [
       "TRUE"
      ],
      "text/plain": [
       "[1] TRUE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "all(y %in% x) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La siguiente línea checa que `c(3,3,7)` esté en `x`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "FALSE"
      ],
      "text/latex": [
       "FALSE"
      ],
      "text/markdown": [
       "FALSE"
      ],
      "text/plain": [
       "[1] FALSE"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "isin(x,y) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Eventos a partir de operaciones entre conjuntos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Union, Intersección y diferencia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un evento es un subconjunto y como tal se realizan operaciones de conjuntos para obtener nuevos eventos. En `prob` se utilizan las funciones [union](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/union), [intersect](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/intersect) y [setdiff](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/setdiff) para tales operaciones. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "S <- cards()\n",
    "A <- subset(S, suit == \"Heart\")\n",
    "B <- subset(S, rank %in% 7:9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 6 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th></th><th scope=col>rank</th><th scope=col>suit</th></tr>\n",
       "\t<tr><th></th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;fct&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><th scope=row>6</th><td>7</td><td>Club   </td></tr>\n",
       "\t<tr><th scope=row>7</th><td>8</td><td>Club   </td></tr>\n",
       "\t<tr><th scope=row>8</th><td>9</td><td>Club   </td></tr>\n",
       "\t<tr><th scope=row>19</th><td>7</td><td>Diamond</td></tr>\n",
       "\t<tr><th scope=row>20</th><td>8</td><td>Diamond</td></tr>\n",
       "\t<tr><th scope=row>21</th><td>9</td><td>Diamond</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 6 × 2\n",
       "\\begin{tabular}{r|ll}\n",
       "  & rank & suit\\\\\n",
       "  & <fct> & <fct>\\\\\n",
       "\\hline\n",
       "\t6 & 7 & Club   \\\\\n",
       "\t7 & 8 & Club   \\\\\n",
       "\t8 & 9 & Club   \\\\\n",
       "\t19 & 7 & Diamond\\\\\n",
       "\t20 & 8 & Diamond\\\\\n",
       "\t21 & 9 & Diamond\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 6 × 2\n",
       "\n",
       "| <!--/--> | rank &lt;fct&gt; | suit &lt;fct&gt; |\n",
       "|---|---|---|\n",
       "| 6 | 7 | Club    |\n",
       "| 7 | 8 | Club    |\n",
       "| 8 | 9 | Club    |\n",
       "| 19 | 7 | Diamond |\n",
       "| 20 | 8 | Diamond |\n",
       "| 21 | 9 | Diamond |\n",
       "\n"
      ],
      "text/plain": [
       "   rank suit   \n",
       "6  7    Club   \n",
       "7  8    Club   \n",
       "8  9    Club   \n",
       "19 7    Diamond\n",
       "20 8    Diamond\n",
       "21 9    Diamond"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head(union(A,B)) #se utiliza head para obtener sólo algunos renglones de la operación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 3 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th></th><th scope=col>rank</th><th scope=col>suit</th></tr>\n",
       "\t<tr><th></th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;fct&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><th scope=row>32</th><td>7</td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>33</th><td>8</td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>34</th><td>9</td><td>Heart</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 3 × 2\n",
       "\\begin{tabular}{r|ll}\n",
       "  & rank & suit\\\\\n",
       "  & <fct> & <fct>\\\\\n",
       "\\hline\n",
       "\t32 & 7 & Heart\\\\\n",
       "\t33 & 8 & Heart\\\\\n",
       "\t34 & 9 & Heart\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 3 × 2\n",
       "\n",
       "| <!--/--> | rank &lt;fct&gt; | suit &lt;fct&gt; |\n",
       "|---|---|---|\n",
       "| 32 | 7 | Heart |\n",
       "| 33 | 8 | Heart |\n",
       "| 34 | 9 | Heart |\n",
       "\n"
      ],
      "text/plain": [
       "   rank suit \n",
       "32 7    Heart\n",
       "33 8    Heart\n",
       "34 9    Heart"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "intersect(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 10 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th></th><th scope=col>rank</th><th scope=col>suit</th></tr>\n",
       "\t<tr><th></th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;fct&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><th scope=row>27</th><td>2 </td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>28</th><td>3 </td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>29</th><td>4 </td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>30</th><td>5 </td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>31</th><td>6 </td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>35</th><td>10</td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>36</th><td>J </td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>37</th><td>Q </td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>38</th><td>K </td><td>Heart</td></tr>\n",
       "\t<tr><th scope=row>39</th><td>A </td><td>Heart</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 10 × 2\n",
       "\\begin{tabular}{r|ll}\n",
       "  & rank & suit\\\\\n",
       "  & <fct> & <fct>\\\\\n",
       "\\hline\n",
       "\t27 & 2  & Heart\\\\\n",
       "\t28 & 3  & Heart\\\\\n",
       "\t29 & 4  & Heart\\\\\n",
       "\t30 & 5  & Heart\\\\\n",
       "\t31 & 6  & Heart\\\\\n",
       "\t35 & 10 & Heart\\\\\n",
       "\t36 & J  & Heart\\\\\n",
       "\t37 & Q  & Heart\\\\\n",
       "\t38 & K  & Heart\\\\\n",
       "\t39 & A  & Heart\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 10 × 2\n",
       "\n",
       "| <!--/--> | rank &lt;fct&gt; | suit &lt;fct&gt; |\n",
       "|---|---|---|\n",
       "| 27 | 2  | Heart |\n",
       "| 28 | 3  | Heart |\n",
       "| 29 | 4  | Heart |\n",
       "| 30 | 5  | Heart |\n",
       "| 31 | 6  | Heart |\n",
       "| 35 | 10 | Heart |\n",
       "| 36 | J  | Heart |\n",
       "| 37 | Q  | Heart |\n",
       "| 38 | K  | Heart |\n",
       "| 39 | A  | Heart |\n",
       "\n"
      ],
      "text/plain": [
       "   rank suit \n",
       "27 2    Heart\n",
       "28 3    Heart\n",
       "29 4    Heart\n",
       "30 5    Heart\n",
       "31 6    Heart\n",
       "35 10   Heart\n",
       "36 J    Heart\n",
       "37 Q    Heart\n",
       "38 K    Heart\n",
       "39 A    Heart"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "setdiff(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 6 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th></th><th scope=col>rank</th><th scope=col>suit</th></tr>\n",
       "\t<tr><th></th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;fct&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><th scope=row>6</th><td>7</td><td>Club   </td></tr>\n",
       "\t<tr><th scope=row>7</th><td>8</td><td>Club   </td></tr>\n",
       "\t<tr><th scope=row>8</th><td>9</td><td>Club   </td></tr>\n",
       "\t<tr><th scope=row>19</th><td>7</td><td>Diamond</td></tr>\n",
       "\t<tr><th scope=row>20</th><td>8</td><td>Diamond</td></tr>\n",
       "\t<tr><th scope=row>21</th><td>9</td><td>Diamond</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 6 × 2\n",
       "\\begin{tabular}{r|ll}\n",
       "  & rank & suit\\\\\n",
       "  & <fct> & <fct>\\\\\n",
       "\\hline\n",
       "\t6 & 7 & Club   \\\\\n",
       "\t7 & 8 & Club   \\\\\n",
       "\t8 & 9 & Club   \\\\\n",
       "\t19 & 7 & Diamond\\\\\n",
       "\t20 & 8 & Diamond\\\\\n",
       "\t21 & 9 & Diamond\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 6 × 2\n",
       "\n",
       "| <!--/--> | rank &lt;fct&gt; | suit &lt;fct&gt; |\n",
       "|---|---|---|\n",
       "| 6 | 7 | Club    |\n",
       "| 7 | 8 | Club    |\n",
       "| 8 | 9 | Club    |\n",
       "| 19 | 7 | Diamond |\n",
       "| 20 | 8 | Diamond |\n",
       "| 21 | 9 | Diamond |\n",
       "\n"
      ],
      "text/plain": [
       "   rank suit   \n",
       "6  7    Club   \n",
       "7  8    Club   \n",
       "8  9    Club   \n",
       "19 7    Diamond\n",
       "20 8    Diamond\n",
       "21 9    Diamond"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head(setdiff(B,A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la siguiente línea se calcula A^c (el complemento de A definido como S\\A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 6 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th></th><th scope=col>rank</th><th scope=col>suit</th></tr>\n",
       "\t<tr><th></th><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;fct&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><th scope=row>1</th><td>2</td><td>Club</td></tr>\n",
       "\t<tr><th scope=row>2</th><td>3</td><td>Club</td></tr>\n",
       "\t<tr><th scope=row>3</th><td>4</td><td>Club</td></tr>\n",
       "\t<tr><th scope=row>4</th><td>5</td><td>Club</td></tr>\n",
       "\t<tr><th scope=row>5</th><td>6</td><td>Club</td></tr>\n",
       "\t<tr><th scope=row>6</th><td>7</td><td>Club</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 6 × 2\n",
       "\\begin{tabular}{r|ll}\n",
       "  & rank & suit\\\\\n",
       "  & <fct> & <fct>\\\\\n",
       "\\hline\n",
       "\t1 & 2 & Club\\\\\n",
       "\t2 & 3 & Club\\\\\n",
       "\t3 & 4 & Club\\\\\n",
       "\t4 & 5 & Club\\\\\n",
       "\t5 & 6 & Club\\\\\n",
       "\t6 & 7 & Club\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 6 × 2\n",
       "\n",
       "| <!--/--> | rank &lt;fct&gt; | suit &lt;fct&gt; |\n",
       "|---|---|---|\n",
       "| 1 | 2 | Club |\n",
       "| 2 | 3 | Club |\n",
       "| 3 | 4 | Club |\n",
       "| 4 | 5 | Club |\n",
       "| 5 | 6 | Club |\n",
       "| 6 | 7 | Club |\n",
       "\n"
      ],
      "text/plain": [
       "  rank suit\n",
       "1 2    Club\n",
       "2 3    Club\n",
       "3 4    Club\n",
       "4 5    Club\n",
       "5 6    Club\n",
       "6 7    Club"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "head(setdiff(S,A)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modelos de probabilidad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modelo de la teoría de la medida"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este modelo consiste en definir una medida de probabilidad en el espacio muestral. Tal medida es una función matemática que satisface ciertos axiomas y tienen ciertas propiedades matemáticas. Existen una amplia gama de medidas de probabilidad de las cuales se elegirá una sola basada en los experimentos y la persona en cuestión que los realizará.\n",
    "\n",
    "Una vez elegida la medida de probabilidad, todas las asignaciones de probabilidad a eventos están hechas por la misma.\n",
    "\n",
    "Este modelo se sugiere para experimentos que exhiban simetría, por ejemplo el lanzamiento de una moneda. Si no exhibe simetría o si se desea incorporar conocimiento subjetivo al modelo resulta más difícil la elección de la medida de probabilidad.\n",
    "\n",
    "Andréi Nikoláyevich Kolmogórov revolucionó la teoría de la probabilidad con este modelo. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modelo frecuentista"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este modelo enuncia que la forma de asignar probabilidades a eventos es por medio de la realización repetida del experimento bajo las mismas condiciones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo, si se desea calcular la probabilidad del evento: $E=${obtener sol} entonces: $$P(E) \\approx \\frac{n_E}{n}$$ donde: $n_E$ representa el número observado de soles (ocurrencia del evento $E$) en $n$ experimentos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tal modelo utiliza la **ley fuerte de los grandes números** en la que se describe y asegura que bajo mismas condiciones de experimentos realizados e independientes, si $n \\rightarrow \\infty$ entonces $\\frac{n_E}{n} \\rightarrow P(E)$.\n",
    "\n",
    "La probabilidad en este enfoque proporciona una medida cuantitativa de qué tan frecuentemente podemos esperar que ocurra un evento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este modelo es sugerido aún si los experimentos no son simétricos (caso del modelo anterior) pero el cálculo de la probabilidad está basado en una aproximación de la forma *in the long run* por lo que no se conoce de forma exacta la misma ni funciona en experimentos que no puedan repetirse indefinidamente, como la probabilidad del evento {el día $x$ lloverá} o {temblor en una zona $z$}."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Richard von Mises fue un personaje importante en el impulso de este modelo, además algunas de sus ideas fueron incorporadas en el modelo de teoría de la medida."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modelo subjetivo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se interpreta a la probabilidad como un \"grado de creencia\" que ocurrirá el evento de acuerdo a la persona que realizará el experimento. La estimación de la probabilidad de un evento se basa en el conocimiento individual de la persona en un punto del tiempo, sin embargo, al ir adquiriendo o poseyendo mayor conocimiento, la estimación se modifica/actualiza de acuerdo a esto. El método típico por el que se actualiza la probabilidad es con la **regla o fórmula o teorema de Bayes**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo, supóngase que al inicio del experimento del lanzamiento de una moneda y el evento {sol} la observadora asigna $P({\\text{sol}}) = \\frac{1}{2}$. Sin embargo, por alguna razón la observadora conoce información adicional acerca de la moneda o de la persona que lanzará la moneda por lo que **decide** modificar su asignación **inicial** de la probabilidad de obtener sol alejado del valor $\\frac{1}{2}$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se define la probabilidad como el grado (personal) de creencia o certeza que se tiene de que el evento suceda.\n",
    "\n",
    "Este modelo se sugiere en situaciones que no es posible repetir indefinidamente el experimento o carece de datos confiables o es prácticamente imposible. Sin embargo, cuando se trata de analizar situaciones para las cuales los datos son escasos, cuestionables o inexistentes, entonces las probabilidades subjetivas difieren enormemente. Un analista deportivo puede pensar que los Cavaliers ganarán el campeonato con un 60% de certeza, mientras que otro puede asegurar que los Lakers de Los Ángeles serán campeones con 95% de certeza.\n",
    "\n",
    "Pierre Simone-Laplace, Frank Ramsey, Bruno De Finetti, Leonard Savage y John Keynes fueron de las personas que popularizaron este modelo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Nota** \n",
    "\n",
    "Cuando se trabaja con un gran número de datos, los modelos frecuentistas y subjetivos tienden a coincidir pero, cuando los datos son escasos o prácticamente inexistentes, las interpretaciones difieren. \n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modelo equiprobable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este modelo asigna igual probabilidad a todos los resultados de un experimento y lo podemos encontrar en los modelos anteriores:\n",
    "\n",
    "* En el modelo de la teoría de la medida al tener un experimento que exhibe simetría de algún tipo, por ejemplo en el lanzamiento de una moneda o dados justos o de un dardo a un tiro al blanco con un mismo radio de circunferencia.\n",
    "\n",
    "* En el modelo subjetivo si la persona que realiza el experimento tiene ignorancia o indiferencia respecto a su grado de creencia del resultado del experimento.\n",
    "\n",
    "* En el modelo frecuentista al observar la proporción de veces que al lanzar una moneda se obtiene sol.\n",
    "\n",
    "Obsérvese que este modelo es posible utilizar si se pueden ennumerar todos los resultados de un experimento."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Espacio de probabilidad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un espacio de probabilidad se compone por el espacio de resultados o espacio muestral, $S$, los eventos $E$ y la medida de los eventos o función de probabilidad que satisfacen los axiomas de Kolmogorov."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Cómo representar en R un espacio de probabilidad?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una opción para responder esta pregunta es considerar un objeto, `S`, que represente los *outcomes* o resultados del experimento y un vector de probabilidades, `probs`, con entradas que correspondan a cada outcome en `S`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además en el paquete *prob* se tiene una función [probspace](https://www.rdocumentation.org/packages/prob/versions/1.0-1/topics/probspace) que tiene por argumentos `x` que es un espacio muestral de los outcomes y `probs` es un vector del mismo tamaño que el número de outcomes en $x$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1) Lanzamiento de un dado justo**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 6 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th scope=col>X1</th><th scope=col>probs</th></tr>\n",
       "\t<tr><th scope=col>&lt;int&gt;</th><th scope=col>&lt;dbl&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><td>1</td><td>0.1666667</td></tr>\n",
       "\t<tr><td>2</td><td>0.1666667</td></tr>\n",
       "\t<tr><td>3</td><td>0.1666667</td></tr>\n",
       "\t<tr><td>4</td><td>0.1666667</td></tr>\n",
       "\t<tr><td>5</td><td>0.1666667</td></tr>\n",
       "\t<tr><td>6</td><td>0.1666667</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 6 × 2\n",
       "\\begin{tabular}{ll}\n",
       " X1 & probs\\\\\n",
       " <int> & <dbl>\\\\\n",
       "\\hline\n",
       "\t 1 & 0.1666667\\\\\n",
       "\t 2 & 0.1666667\\\\\n",
       "\t 3 & 0.1666667\\\\\n",
       "\t 4 & 0.1666667\\\\\n",
       "\t 5 & 0.1666667\\\\\n",
       "\t 6 & 0.1666667\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 6 × 2\n",
       "\n",
       "| X1 &lt;int&gt; | probs &lt;dbl&gt; |\n",
       "|---|---|\n",
       "| 1 | 0.1666667 |\n",
       "| 2 | 0.1666667 |\n",
       "| 3 | 0.1666667 |\n",
       "| 4 | 0.1666667 |\n",
       "| 5 | 0.1666667 |\n",
       "| 6 | 0.1666667 |\n",
       "\n"
      ],
      "text/plain": [
       "  X1 probs    \n",
       "1 1  0.1666667\n",
       "2 2  0.1666667\n",
       "3 3  0.1666667\n",
       "4 4  0.1666667\n",
       "5 5  0.1666667\n",
       "6 6  0.1666667"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "outcomes <- rolldie(1)\n",
    "p <- rep(1/6, times = 6)\n",
    "probspace(outcomes, probs = p)\n",
    "#equivalently \n",
    "#probspace(1:6, probs = p) or probspace(1:6) or rolldie(1, makespace = TRUE)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2) Lanzamiento de una moneda cargada**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Supóngase que $P(\\{\\text{sol}\\}) = .7$ y $P(\\{\\text{águila}\\}) = .3$ entonces:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table class=\"dataframe\">\n",
       "<caption>A data.frame: 2 × 2</caption>\n",
       "<thead>\n",
       "\t<tr><th scope=col>toss1</th><th scope=col>probs</th></tr>\n",
       "\t<tr><th scope=col>&lt;fct&gt;</th><th scope=col>&lt;dbl&gt;</th></tr>\n",
       "</thead>\n",
       "<tbody>\n",
       "\t<tr><td>H</td><td>0.7</td></tr>\n",
       "\t<tr><td>T</td><td>0.3</td></tr>\n",
       "</tbody>\n",
       "</table>\n"
      ],
      "text/latex": [
       "A data.frame: 2 × 2\n",
       "\\begin{tabular}{ll}\n",
       " toss1 & probs\\\\\n",
       " <fct> & <dbl>\\\\\n",
       "\\hline\n",
       "\t H & 0.7\\\\\n",
       "\t T & 0.3\\\\\n",
       "\\end{tabular}\n"
      ],
      "text/markdown": [
       "\n",
       "A data.frame: 2 × 2\n",
       "\n",
       "| toss1 &lt;fct&gt; | probs &lt;dbl&gt; |\n",
       "|---|---|\n",
       "| H | 0.7 |\n",
       "| T | 0.3 |\n",
       "\n"
      ],
      "text/plain": [
       "  toss1 probs\n",
       "1 H     0.7  \n",
       "2 T     0.3  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "probspace(tosscoin(1), probs = c(0.70, 0.30))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**(Tarea) Ejercicio** \n",
    "\n",
    "¿Cómo calcular la probabilidad anterior con la función `urnsamples`?\n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "4.2.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}