{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5DaWfnWCxdDy"
      },
      "source": [
        "CARA Y SELLO\n",
        "\n",
        "Resumen\n",
        "\n",
        "La Ciencia se basa en el método científico, que ofrece un procedimiento para formular y aceptar o rechazar proposiciones sobre la naturaleza. En Ciencia, la aleatoriedad es la primera explicación de cualquier fenómeno. Aquí mostramos cómo funciona esto cuando tenemos dos eventos o resultados producidos por una moneda, a los que llamamos cara y sello, o también cara y cruz. Cara puede corresponder a ser hombre, a pertenecer a la derecha política, a tener más de 30 años, o a ser indiferente a las peticiones de ayuda de un país sometido a un ataque injusto, o a una mutación favorable. En la literatura, este tema se conoce como la Distribución Binomial. Si su desafío es aprender o enseñar los conceptos detrás de las fórmulas y de los procedimientos estadísticos, pruebe este material. Utilícelo también para aprender Python 3, un lenguaje de programación muy extendido y popular entre los científicos, y cómo trabajar con IA para mejorar y desarrollar software. Los conceptos que se muestran aquí son universales y toda la ciencia es más de lo mismo.\n",
        "\n",
        " # INTRODUCCIÓN\n",
        "\n",
        "Ayer visité a una familia, y en la casa había un gato y un perro. Ambos estaban impulsados ​​por la curiosidad, pero el gato dirigió su silenciosa atención a las cosas que yo les había traído, mientras que el perro me ladraba sin parar hasta que finalmente nos hicimos amigos. Por su comportamiento, vemos que poseen una maquinaria neuronal para distinguir lo habitual y familiar de lo inusual y desconocido. Los bebés humanos pueden ejercitar esta capacidad desde su primer año de vida. Por lo tanto, nos entrenamos para comparar cosas de cualquier naturaleza y tomar las decisiones consiguientes. La Ciencia es una especialización de esta capacidad.\n",
        "\n",
        "***El propósito de la Ciencia es comparar lo que pensamos con lo que observamos para perfeccionar nuestras ideas sobre la naturaleza.***\n",
        "\n",
        "> **Ejemplo.** La primera explicación científica de cualquier fenómeno es la aleatoriedad. Si no funciona, intentamos inventar otra explicación. Así, la aleatoriedad explica la gravedad de la siguiente manera:\n",
        ">>\n",
        ">> Las cosas se mueven aleatoriamente por naturaleza, y caen hacia la Tierra porque, por pura casualidad, su movimiento aleatorio está alineado hacia abajo. Pero esto puede cambiar en cualquier momento, y las cosas podrían empezar a levitar o a deslizarse horizontalmente.\n",
        ">>\n",
        ">> Ahora bien, nosotros, los seres humanos, no creemos en esta explicación porque esperamos que el movimiento aleatorio sea aleatorio, es decir, que varíe sin ley, lo que imposibilita predecir qué ocurrirá después. Sin embargo, esto no es lo que pasa mientras los cuerpos caen o permanecen inmóviles. De hecho, predecimos con éxito infalible que los cuerpos libres caen y se mueven hacia la Tierra. Más concretamente, hemos recopilado más datos y creemos que, en la proximidad de la Tierra, la teoría de Newton es compatible con la observación: los cuerpos se atraen entre sí con una fuerza proporcional al producto de sus masas e inversamente al cuadrado de su distancia. Para datos planetarios y más allá, como en la proximidad de un agujero negro, la teoría de la relatividad general de Einstein es mucho mejor, en la que la aceleración resulta de la curvatura del espacio-tiempo.\n",
        "\n",
        "Se presta especial atención al caso en el que la diferencia entre lo observado y lo esperado puede medirse. Si es baja, la Ciencia aconseja en primera instancia seguir creyendo lo que pensamos, pero si esa diferencia es alta, la Ciencia aconseja considerar otros pensamientos, otras explicaciones. Nótese que **la Ciencia es un consejero, no un dictador dogmático. Son los seres humanos los que aceptan o rechazan los consejos de la Ciencia y toman decisiones bajo su exclusiva responsabilidad**.\n",
        "\n",
        "Surge una pregunta inmediata: *¿Cómo podemos comparar lo que pensamos, algo  subjetivo, con la realidad objetiva observada por la Ciencia?*\n",
        "\n",
        "Los pensamientos se organizan en forma de teoría, y esta se ve obligada a producir predicciones observables. Así, terminamos comparando los resultados previstos con los eventos observados o, simplemente, lo previsto con lo observado. Por ejemplo, hemos dicho que en el momento de una visita a un hogar, los perros prestan más atención a los seres humanos que a las cosas, mientras que los gatos son al revés. De esto, derivamos una predicción: los ladrones prefieren robar en apartamentos donde hay gatos en lugar de donde hay perros. Tenemos una teoría y una predicción razonable. El siguiente paso es comparar lo previsto con lo observado. Si descubrimos que los robos en casas ocurren con mucha mayor frecuencia donde había gatos y no perros, podemos seguir creyendo que los perros son mucho mejores guardianes que los gatos.\n",
        "\n",
        "Tomar decisiones es más fácil cuando las cosas son claras que cuando los datos son difusos. De hecho, un problema crucial con los datos observados es que, en general, no son deterministas ni están claramente establecidos. En cambio, presentan variaciones que podrían ser difíciles de explicar y que pueden considerarse aleatorias, es decir, difíciles de encajar en un patrón determinista. Pero necesitamos tomar decisiones a diario, quizás a cada hora. Pensemos, por ejemplo, en el clima, que nos muestra que tomar decisiones ante la aleatoriedad es una tarea verdaderamente difícil, plagada de fracasos indeseables.\n",
        "\n",
        "Es por eso que nuestro propósito es desarrollar el caso más simple de toma de decisiones con datos aleatorios y mostrar el formalismo subyacente habitual en la Ciencia. Consideramos que, en cuanto a principios y procedimientos básicos, toda la Ciencia es más de lo mismo, de lo que veremos aquí. Trabajaremos con una moneda y simularemos su comportamiento en Python, un lenguaje de programación muy popular entre los científicos. Ejecutar programas es una obligación, ya que para contrastar nuestras creencias con lo observado, necesitamos calcular las predicciones de nuestras creencias, tarea que se realiza mediante simulaciones. De todos modos, todos los programas Python se pueden ejecutar con un solo clic desde este cuaderno gracias al servicio gratuito Colab de Google. Un solo clic es suficiente para ejecutar un programa.\n",
        "\n",
        "**Analicemos ahora una pregunta importante: ¿cómo podemos tomar decisiones ante la aleatoriedad, dado que no podemos comprender su comportamiento? La respuesta es: aunque desconocemos qué sucederá después, podemos estimar qué será mejor a largo plazo y qué tendencias surgirán.**\n",
        "\n",
        "> **Ejemplo.** Consideremos un juego con un dado justo, cuya geometría es perfectamente simétrica. El juego consiste en apostar a la mejor de dos opciones. La primera es apostar a seis, mientras que la segunda es apostar a cinco o menos. Elegimos inmediatamente la segunda apuesta porque su probabilidad es cinco veces mayor que la primera. Observemos que hacemos esto a pesar de desconocer qué sucederá después. Pero esperamos que, a largo plazo, después de muchas apuestas, la segunda opción sea la ganadora.\n",
        "\n",
        "En general, podemos decir: para tomar decisiones ante la aleatoriedad, debemos buscar tendencias hacia observables deterministas y explotarlas en nuestro beneficio (un observable es una variable que se puede medir o el resultado de su manipulación matemática). La tendencia en el ejemplo de los dados es que, tras muchos intentos, la proporción relativa de cinco o menos será cinco veces mayor que la de seis.\n",
        "\n",
        "A continuación, se presenta un ejemplo muy importante de tendencias.\n",
        "\n",
        "## Teorema de la autoaniquilación de las desviaciones de la media.\n",
        "\n",
        "Tomar decisiones siempre exige representar una población de datos mediante una muestra o, quizás, mediante un número abstracto, lo cual se realiza según los objetivos previstos.\n",
        "\n",
        "> **Ejemplo.** Necesitamos la imagen de un grupo de alumnos, y solo tenemos su rendimiento en un examen de matemáticas. Si nuestro objetivo es impresionar, tomaremos la mejor puntuación. Si nuestro objetivo es señalar las deficiencias del trabajo del profesor, tomaremos la puntuación más baja. Y si buscamos al mejor representante, reportaremos la media, que es un número abstracto.\n",
        "\n",
        "La media tiene dos virtudes fundamentales: representa a la población democráticamente, otorgando el mismo peso a todos los datos, y minimiza las tensiones internas creadas por ser diferente de la media. Esto significa que existe una discrepancia entre la media y cada dato, pero todas las discrepancias se cancelan entre sí. Formalmente:\n",
        "\n",
        "> **Teorema.** Consideremos un conjunto de datos compuesto por los números $a_1, a_2,...,a_n$ con media $\\bar{a}$. Entonces, las desviaciones con respecto a la media, $\\bar{a} - a_i$, suman cero.\n",
        "\n",
        ">>Demostración. La media se obtiene sumando todos los términos y dividiendo el resultado entre el número de términos:\n",
        ">>\n",
        ">>>$\\bar{a} = \\sum^n_{i=1} a_i = \\frac{a_1 + a_2 + ... + a_n}{n}$\n",
        ">>\n",
        ">>Las desviaciones con respecto a la media son $\\bar{a} - a_1 $, $\\bar{a} - a_2 $ ... $\\bar{a} - a_n $. Entonces, su suma $S$ es:\n",
        ">>>\n",
        ">>>$ S = \\bar{a} - a_1 + \\bar{a} - a_2 + ... +\\bar{a} - a_n $\n",
        ">>\n",
        ">>Asociemos las medias, $n$ en total, y coloquemos los demás sumandos entre paréntesis:\n",
        ">>>>\n",
        ">>>$ S = n\\bar{a} - (a_1 + a_2+...a_n) $\n",
        ">>>\n",
        ">>>$ = n \\frac{a_1 + a_2 + ... + a_n}{n} - (a_1 + a_2+...a_n)$\n",
        ">>>\n",
        ">>>$ = (a_1 + a_2+...a_n) - (a_1 + a_2+...a_n) = 0$.\n",
        ">>\n",
        "> Hemos demostrado que las desviaciones de los datos con respecto a la media suman 0.\n",
        "\n",
        "\n",
        "Este teorema es válido para todo tipo de datos numéricos, en particular para datos aleatorios. Ahora bien, cuando la fuente de datos presenta cierto grado de estabilidad u homogeneidad, la media también es estable, en el sentido de que sus variaciones de un lugar a otro o de un momento a otro pueden ignorarse, en una primera aproximación. En ese caso, la estabilidad aumenta al añadir más datos, y la media se vuelve cada vez más determinada: la media de una muestra tiende a acercarse a la media de la población. Todo esto explica por qué la media aparece en todas partes en la Ciencia y en la toma de decisiones. Y también por eso cualquiera puede cometer errores graves, por ejemplo, si se recopilan datos sesgados que representan a una subpoblación, pero se toman decisiones que afectan a toda la población no homogénea.\n",
        "\n",
        "> **Ejemplo.** Una aerolínea promete que, como firme compromiso con su servicio, el vuelo durará 1 hora y 40 minutos. ¿Cómo puede ser posible una promesa tan exacta, si todo el mundo sabe que la duración del vuelo varía? Esto sucede así: la aerolínea calcula la duración media,  y encuentra que las desviaciones respecto a la media son iguales o inferiores a 5 minutos. Por lo tanto, nadie protesta contra la propaganda de la aerolínea. La media tiene aquí gran poder predictivo. Sin embargo, la media no siempre representa tan bien a la población. Por ejemplo, si se viaja por las montañas en coche, las duraciones se dan en otro formato. Preferimos decir: el viaje dura entre 8 y 12 horas, y no se menciona la media porque tiene un bajo poder predictivo.\n",
        "\n",
        "Al trabajar con monedas, encontraremos medias y frecuencias relativas como nuestros principales observables, con una tendencia a la estabilidad, al determinismo y a los valores de la población.\n",
        "\n",
        "# MONEDAS COMO MODELO\n",
        "\n",
        "Una moneda tiene dos caras, llamadas genéricamente cara y cruz, o también cara y sello. La gente está acostumbrada a creer que es justo apostar por cualquiera de las dos. En otras palabras, tenemos una creencia: la probabilidad de cara es igual a la de cruz, igual a 0,5. La probabilidad indica cuán justo es apostar por una cara dada; por lo tanto, cuando decimos que la probabilidad de cara es igual a la de cruz, simplemente decimos que es justo apostar por cualquiera de las caras de una moneda. Nos referimos a cara y cruz como eventos. Apostar a lanzar monedas es un juego popular porque no se puede predecir con certeza qué caerá después, si cara o cruz. Decimos que, en cualquier lanzamiento, las monedas caen al azar y con la misma probabilidad. También asumimos que los lanzamientos son independientes, es decir, que un lanzamiento no cambia las frecuencias relativas futuras. La *frecuencia relativa* de cara es el número de caras dividido entre el número total de intentos o lanzamientos.\n",
        "\n",
        "**Enmarquemos nuestra discusión en una pregunta intrigante ya mencionada: si las monedas caen al azar y la incertidumbre predomina, ¿cómo podemos hacer Ciencia? ¿Cómo podemos formular proposiciones verbales que orienten la toma de decisiones?**\n",
        "\n",
        "Para empezar, observamos que tenemos la idea preconcebida de que es justo apostar a cara o cruz. Expresémosla en la jerga oficial: nuestra idea preconcebida se denomina hipótesis nula y se denota $H_o$, y dice que la probabilidad de cara es igual a la de cruz.\n",
        "\n",
        "El segundo paso en el camino de la Ciencia es relacionar el concepto abstracto y subjetivo de probabilidad, basado en la imparcialidad, con observaciones objetivas. El vínculo inmediato es la frecuencia relativa de caras, cuando se permite un número determinado de repeticiones independientes. Esperamos, según nuestra $H_o$, que la frecuencia relativa de caras se acerque a 0,5, y que esto sea más cierto cuanto mayor sea el número de repeticiones. Con esto, afirmamos que *las repeticiones crean tendencias en las frecuencias relativas que se reafirman al aumentar el número de repeticiones*. Concretamente, nuestra expectativa es:\n",
        "\n",
        "Cuando se permiten repeticiones independientes, aparece una tendencia en la frecuencia relativa de caras que tiende a un límite: su probabilidad. ¿Se cumple esta expectativa? ¿Existen otras tendencias hacia un límite? ¿Cómo podemos usarlas en la Ciencia?\n",
        "\n",
        "> **Las tendencias son útiles en la Ciencia** para caracterizar un entorno experimental. Esto nos permite comparar diferentes entornos, diferentes experimentos, y concluir que producen el mismo resultado o uno diferente, que tienen el mismo o diferente comportamiento. Pero, ¿cómo resolveremos la acusación de que los resultados siempre incluyen aleatoriedad e incertidumbre y que, por lo tanto, nuestras conclusiones podrían ser banales o incluso engañosas?\n",
        "\n",
        "Nuestra respuesta a esta acusación es trabajar en detalle un ejemplo completo. Nuestro caso de estudio es simplemente el de una moneda, y nuestra creencia a comprobar, nuestra $H_o$, es simplemente que la probabilidad de cara es 0,5.\n",
        "\n",
        "## FRECUENCIA RELATIVA COMO TENDENCIA\n",
        "\n",
        "*En esta sección, investigamos qué sucede con la frecuencia relativa de caras cuando aumenta el número de lanzamientos de una moneda.* ¿Se observa una tendencia hacia un límite que coincide con la probabilidad?\n",
        "\n",
        "Esta pregunta debe responderse experimentalmente. Pero, atención, ponemos a prueba creencias que solo existen en nuestra mente. Nuestras creencias se refieren a escenarios experimentales: una moneda con dos caras, una con un dibujo y la otra con un número, y ambas caras caen hacia arriba con la misma probabilidad: 1/2 = 0,5. Además, los eventos son independientes, lo que significa que cualquier lanzamiento podría considerarse el inicial o, equivalentemente, que un lanzamiento o resultado dado no interfiere con el resultado de los lanzamientos futuros.\n",
        "\n",
        "*Es instructivo, pero extremadamente difícil, controlar con precisión los experimentos con monedas reales. Por eso, valoramos la posibilidad de realizar experimentos dentro de la memoria de una computadora con casi exactamente las condiciones requeridas y la misma preparación. Estos experimentos se denominan simulaciones.* **En el resto de esta sección, profundizaremos en el concepto de probabilidad como una frecuencia relativa idealizada**. Utilizaremos Python para nuestras simulaciones, ya que Google Colab nos permite ejecutar programas en este lenguaje sin esfuerzo. Esto es posible porque en este cuaderno de Jupyterlab, el texto y los programas se encuentran en celdas diferentes, y Colab nos permite ejecutar las celdas de los programas con un solo clic.\n",
        "\n",
        "## Simulación de una moneda\n",
        "\n",
        "Nuestro primer programa simula el lanzamiento de una moneda varias veces y registra el resultado.\n",
        "\n",
        "> **Ejemplo.** Simulemos el lanzamiento de una moneda 7 veces.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xrUncxr7x9xK"
      },
      "outputs": [],
      "source": [
        "# Program CoinSimulation\n",
        "import random\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FK7RAcvXx9xN"
      },
      "source": [
        "> **Ejercicio.** Ejecuta el código, observa su salida y analízalo. *Para ejecutar el código, abre este documento en Colab, arrastra el cursor sobre la celda del programa y haz clic en el icono emergente de la esquina superior izquierda. Para usar Colab, escribe \"Colab\" en Google. Se abrirá una página web donde podrás abrir y ver documentos de Jupyter y JupiterLab, y ejecutar con un solo clic los programas Python que contienen.*\n",
        "\n",
        ">> **Respuesta.** El código contiene 7 repeticiones del mismo bloque de dos instrucciones. La segunda instrucción imprime el valor de la moneda, por lo que la primera debe ser una instrucción para simular un lanzamiento.\n",
        "\n",
        "Veamos con más detalle el significado del código.\n",
        "\n",
        "> **Ejemplo.** ¿Qué significa este código?\n",
        ">>\n",
        ">> La primera instrucción `# Program CoinSimulation` comienza con el símbolo #, que indica un comentario en Python. Un comentario es un mensaje tanto para el cliente humano como para la IA. En nuestros programas, el primer comentario contiene el nombre del programa.\n",
        ">>\n",
        ">> La instrucción `import random` ordena añadir una biblioteca con el código para generar números aleatorios. *Una biblioteca es un conjunto de herramientas de código con programas que han sido probados exhaustivamente en cuanto a su veracidad, cumplimiento de su función, estilo y eficiencia.* Estos números son generados por miniprogramas que funcionan de forma determinista, por lo que son *pseudoaleatorios*, pero sus secuencias de salida son tan caóticas que producen resultados estadísticamente aceptables.\n",
        ">>\n",
        ">> La instrucción `coin = random.choice([\"Heads\", \"Tails\"])` ordena simular el lanzamiento de una moneda con dos caras con sus nombres habituales y con la misma probabilidad. El resultado de la simulación de cada lanzamiento se escribe en la variable `coin`.\n",
        ">>\n",
        ">> La instrucción `print(coin)` ordena imprimir el valor asignado a la variable `coin` en el momento de la impresión.\n",
        "\n",
        "Es importante tener en cuenta que, al igual que en la vida real, el generador de números aleatorios produce resultados que pueden variar en cada nueva llamada.\n",
        "\n",
        "> **Ejercicio.** Encuentra una manera de repetir el experimento y verifica que el resultado puede variar de una ejecución a otra. En ocasiones, no se produce ningún cambio. ¿Es esto problemático?\n",
        "\n",
        ">> **Respuesta.** Para volver a ejecutar un programa, debemos arrastrar el cursor a la celda de código y luego hacer clic en el icono Ejecutar tantas veces como se desee. Que no haya cambios después de una nueva ejecución no es un problema, ya que esto también puede ocurrir por mera aleatoriedad, como en la vida real.\n",
        "\n",
        "*Los programas son porciones funcionales de código.* Se pueden modificar fácilmente.\n",
        "\n",
        "> **Ejercicio.** Encuentra una manera de modificar el código para simular el lanzamiento de una moneda 14 veces. Prueba tu nuevo código ejecutándolo.\n",
        "\n",
        ">> **Respuesta.** El código para simular el lanzamiento de una moneda 7 veces se copia al portapapeles. Usamos `CTRL + C`. Luego se pega al final del programa existente con `CTRL + V`, o se pega dos veces en una nueva celda de código, manteniendo la misma sangría que las líneas anteriores. El resultado es un programa que simula 14 lanzamientos de moneda, lo cual se puede verificar al ejecutar el programa. El código es el siguiente:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_M-5v05px9xO"
      },
      "outputs": [],
      "source": [
        "# Program CoinSimulation\n",
        "import random\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)\n",
        "\n",
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sZ4-kICmx9xO"
      },
      "source": [
        "Una grata sorpresa: *Colab puede explicar el código.*\n",
        "\n",
        "> **Ejercicio.** Haz clic derecho sobre la celda con el código. Selecciona \"Explicar código\". Compara la explicación ofrecida con la aquí presentada. Da tu opinión a Colab: califica la respuesta como perfecta o imperfecta. Si no aparece a la vista la opción de explicar el código, busque en la esquina superior derecha de la celda de código activa el menú de 3 puntos verticales. Una de las opciones de dicho menú es explicar el código. Úsela y disfrútela.\n",
        "\n",
        ">> **Respuesta.** La explicación de Colab es mucho mejor, más comprensible y más sencilla que la de este texto. Por lo tanto, conviene usar la amabilidad de Colab de forma rutinaria.\n",
        "\n",
        "Para repetir el experimento 14 veces, el código se repitió 14 veces. Claramente, esta estrategia infantil no funciona en simulaciones con cientos de repeticiones. En todos los lenguajes de programación, las repeticiones se implementan mediante bucles, ciclos o loops.\n",
        "\n",
        "> **Ejemplo.** El siguiente código utiliza un bucle para repetir una tarea 7 veces. La tarea consiste en simular el lanzamiento de una moneda."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vlLvDkntx9xP"
      },
      "outputs": [],
      "source": [
        "# Program CoinSimulationWithLoop.py\n",
        "import random\n",
        "\n",
        "# How many flips\n",
        "num_flips = 7; # the symbol underscore _ is here a separator.\n",
        "\n",
        "\"\"\"Loop to simulate multiple coin flips \"\"\"\n",
        "for i in range(num_flips):\n",
        "    coin = random.choice([\"Heads\", \"Tails\"])\n",
        "    # print the values of i and coin.\n",
        "    print(i, coin)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jXpis7wSx9xQ"
      },
      "source": [
        "Comentarios:\n",
        "\n",
        "1. Observe la forma alternativa de marcar un comentario, que se encuentra entre comillas triples \"\"\".\n",
        "2. La instrucción `for i in range(num_flips):` define el bucle. La variable `i` es el contador del ciclo que cuenta el número de ciclos ejecutados desde `0` hasta `num_flips`. La variable se incrementa al inicio de cada ciclo, y la instrucción dice: ejecutar el código en el bloque siguiente, comenzando con la variable de conteo en 0 hasta que la variable alcance su límite superior, que es `num_flips = 7`; la variable `i` cuenta 0, 1, 2, ..., 6 y se detiene.\n",
        "\n",
        "> **Ejercicio.** Ejecute el código y verifique que la variable `i` se ejecute de 0 a 6 y no a 7, ya que se incrementa antes de cada bucle, y si la variable alcanza su límite superior, el bucle debe detenerse.\n",
        "\n",
        "> **Ejercicio.** Encuentre una manera de que el programa `CoinSimulationWithLoop.py` simule 14 lanzamientos.\n",
        "\n",
        ">> **Respuesta.** La variable que define el número de lanzamientos debe establecerse en 14: `num_flips = 14`;\n",
        "\n",
        "## La función de la sangría en Python\n",
        "\n",
        "*La sangría se refiere a los espacios en blanco al principio de una línea de código.* Python estructura el código mediante sangría. Esto significa que el código con sangría forma un bloque dependiente de la primera línea anterior con menos sangría. Por lo tanto, en el programa `CoinSimulationWithLoop.py`, el bucle for ejecuta repetidamente un bloque que consiste en el código con sangría:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZCRBq6jtx9xQ"
      },
      "outputs": [],
      "source": [
        "coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(i, coin)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "21rCAdyFx9xR"
      },
      "source": [
        "La variable `num_flip` indica el número de veces que debe ejecutarse este bloque.\n",
        "\n",
        "> **Ejercicio.** Cambie la sangría de cada línea de este bloque en el programa completo para ver el efecto y explíquelo.\n",
        "\n",
        "> **Respuesta.** El siguiente cambio es viable e imprime el resultado de lanzar la moneda una vez."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XyLp3a95x9xR"
      },
      "outputs": [],
      "source": [
        "for _ in range(num_flips):\n",
        "     coin = random.choice([\"Heads\", \"Tails\"])\n",
        "print(coin)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mc8_1-yJx9xS"
      },
      "source": [
        "> La razón es que el bloque que está dentro del alcance del bucle consta de una sola línea, `coin = random.choice([\"Heads\", \"Tails\"])`, mientras que la instrucción de impresión que aparece a continuación está fuera del bucle. Por lo tanto, Python ejecuta 7 bucles sin imprimir y luego imprime el resultado del último. Otras sangrías producen un error de sangría porque el código resultante no coincide con la sintaxis predefinida.\n",
        "\n",
        "## Guion bajo como nombre de una variable\n",
        "\n",
        "El símbolo `_` se llama *guion bajo*. Es otra letra en Python. Se utiliza como nombre de la variable de conteo en los ciclos cuando esta no aparece en el bloque del ciclo.\n",
        "\n",
        "> **Ejemplo** El siguiente código utiliza el guion bajo como variable del bucle porque no aparece dentro del bloque del bucle."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "a0EqI7Tqx9xS"
      },
      "outputs": [],
      "source": [
        "# Program CoinSimulationUnderscore\n",
        "import random\n",
        "\n",
        "# How many flips\n",
        "num_flips = 7;\n",
        "\n",
        "\"\"\"Loop to simulate multiple coin flips \"\"\"\n",
        "# The symbol _ is  the name of the loop variable,\n",
        "# it is used when the loop variable does not appear in the slave code\n",
        "for _ in range(num_flips):\n",
        "    coin = random.choice([\"Heads\", \"Tails\"])\n",
        "    print(coin)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KRAFjB75x9xT"
      },
      "source": [
        "> **Ejercicio.** Ejecuta este fragmento de código. ¿Qué significa?\n",
        "\n",
        ">> **Respuesta.** El código simula lanzar una moneda 7 veces. El resultado de cada lanzamiento se imprime porque la instrucción correspondiente tiene el mismo nivel de sangría que la anterior.\n",
        "\n",
        "> **Investigación.** Observemos que algunas líneas terminan con punto y coma y otras no. ¿Para qué sirve el punto y coma en Python y qué tan recomendable es? Consejo: escribe esta pregunta como un mensaje en tu navegador.\n",
        "\n",
        "## Código interactivo\n",
        "\n",
        "*Un programa interactivo interactúa con el usuario*.\n",
        "\n",
        "> **Ejemplo** El siguiente ejemplo lo proporciona un miembro de la comunidad: Corre perfecto sobre Colab + Chrome. Con más dificultad sobre Colab + Visual Studio Code porque la casilla del input aparece perdida en la cabecera de la ventana de edición."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7GIwMHJLx9xT"
      },
      "outputs": [],
      "source": [
        "# Program CoinSimulationInteractive\n",
        "\n",
        "# By SuperElephantX\n",
        "# https://www.reddit.com/r/learnpython/comments/1ci995u/comment/l27y5ca/\n",
        "# Retrieved 17/VII/2025\n",
        "\n",
        "import random\n",
        "\n",
        "print(\"Welcome to the Python coin flip\")\n",
        "\n",
        "while input(\"Press enter to flip the coin or type -1 to exit: \") != \"-1\":\n",
        "    coin = random.choice([\"Heads\", \"Tails\"])\n",
        "    print(coin)\n",
        "# Use \" \" to print verbatim\n",
        "print(\"Goodbye!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EcGQcfUrx9xU"
      },
      "source": [
        "> Expliquemos el código:\n",
        ">>\n",
        ">> La instrucción `while input(\"Press enter to flip the coin or type -1 to exit: \") != \"-1\"`: ordena presentar un cuadro de entrada donde el usuario debe escribir `enter` else `-1`. Si la entrada es `enter`, Python ejecuta el código sangrado debajo de la instrucción `while`. Si la entrada es `-1`, Python abandona el bloque `while` y exclama `Goodbye!`. El signo igual `=` significa igual a, pero la expresión `!=` significa distinto de, por lo que `!` es una negación. Por lo tanto, Python abandona el bucle `while` cuando el usuario escribe algo distinto de `-1`.\n",
        "\n",
        "> **Ejercicio.** Ejecute el código anterior y pida a Colab que lo explique. Ejecute el código de nuevo, pero esta vez escriba cualquier letra. Explique la reacción del programa. ¿Qué podría suceder si se introduce una expresión aleatoria?\n",
        "\n",
        ">> **Respuesta.**  Si se escribe una sola letra en el cuadro de entrada, el programa lanza una moneda. Esto se debe a que el programa solo comprueba si la entrada es diferente de `-1` para ejecutar el código sangrado debajo de la instrucción while. En caso contrario, el programa termina.\n",
        "\n",
        "\n",
        "## ¿Problemas con Colab?\n",
        "\n",
        "Si Colab te pide que vuelvas más tarde, significa que Google te invita a comprar un servicio Plus. Así que prueba algunas recomendaciones sencillas para disfrutar de la versión gratuita de Colab y prepárate para descubrir consejos mucho mejores:\n",
        "\n",
        "\n",
        "- Colab funciona mejor en Chrome.\n",
        "\n",
        "\n",
        "- Trabaja de forma continua, no intermitente.\n",
        "\n",
        "\n",
        "- Intenta ejecutar el programa solo una vez.\n",
        "Modifica los parámetros para cada nueva ejecución.\n",
        "\n",
        "\n",
        "- Usa Colab preferentemente para obtener explicaciones del código.\n",
        "\n",
        "\n",
        ". Para ejecutar el código y\n",
        "experimentar con él realizando cambios a voluntad,\n",
        "usa una solución local, como  \n",
        "Visual Studio Code + JupyterLab.\n",
        "\n",
        "- Acepta las quejas y sigue trabajando.\n",
        "\n",
        "\n",
        "- Colab es muy amigable con los desarrolladores.\n",
        "Ofrece sugerencias que casi siempre son oportunas y correctas.\n",
        "\n",
        "\n",
        "- Retroalimenta a Colab cuando tengas una evaluación clara.\n",
        "\n",
        "- La versión gratuita de Colab es una gran ayuda que debe usarse con prudencia.\n",
        "Es lenta con computación de alta complejidad.\n",
        "Úsala para desarrollar tu código, pero considera ejecutarlo en otro lugar.\n",
        "\n",
        "- Ponle un título a tu trabajo, en la casilla correspondiente, y guárdalo   con Ctrl + S.\n",
        "Se guardará en Google Drive.\n",
        "Para recuperar tu trabajo al cerrarlo, escribe \"Colab\"   en Google y selecciona Drive.\n",
        "Colab lo ha guardado.\n",
        "\n",
        "## Encapsulación\n",
        "\n",
        "Los bloques se pueden usar varias veces en el mismo programa. Para evitar repeticiones, se encapsulan, se les asigna un nombre y, a continuación, se referencian por nombre.\n",
        "\n",
        "> **Ejemplo.** El procedimiento de encapsulación sigue el siguiente modelo:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4l3uQTNLx9xU"
      },
      "outputs": [],
      "source": [
        "# Program encapsulation\n",
        "import random\n",
        "\n",
        "# Encapsulation of a flip.\n",
        "# It simulates a flip and report the outcome.\n",
        "# When the capsule is called somewhere else,\n",
        "# the returned value is the only information that is reported.\n",
        "def coin_flip():\n",
        "    \"\"\"Simulates a single coin flip.\"\"\"\n",
        "    return random.choice([\"Heads\", \"Tails\"])\n",
        "\n",
        "# Using the encapsulated code\n",
        "def main():\n",
        "    # Encapsulated code is called\n",
        "    # and result is assigned to the variable coin.\n",
        "    coin = coin_flip()\n",
        "    print(coin)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ez7C0ssrx9xV"
      },
      "source": [
        "La encapsulación se basa en funciones. *Las funciones son procesadores de información que establecen una correspondencia entre la entrada y la salida. Una función encapsulada se denomina `método`*. Pueden recibir o no una entrada que se coloca dentro del paréntesis final () de la definición. En este caso, es `coin_flip()` y no hay entrada. Cada método tiene un nombre y contiene un bloque para ejecutarse, y el resultado puede o no reportarse. Para reportar un resultado, debe ir precedido de la palabra reservada `return`. Esta palabra está reservada porque puede usarse con este único propósito. Para invocar un método, se  lo llama por su nombre. Si la función devuelve un valor, este puede asignarse a una variable, en este caso, `coin`.\n",
        "\n",
        "> **Ejercicio.** Ejecuta el código y haz que Colab lo explique. ¿Es innecesario el último bloque `if` porque se podría reemplazar por `main()`? Observa el doble símbolo igual y explícalo.\n",
        "\n",
        ">> **Respuesta.** Se puede reemplazar el último bloque if por `main()` y el programa se ejecuta y produce el resultado esperado:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WBmJUF2ex9xV"
      },
      "outputs": [],
      "source": [
        "#  Program encapsulation2\n",
        "import random\n",
        "\n",
        "def coin_flip():\n",
        "    \"\"\"Simulates a single coin flip.\"\"\"\n",
        "    return random.choice([\"Heads\", \"Tails\"])\n",
        "\n",
        "def main():\n",
        "    coin = coin_flip()\n",
        "    print(coin)\n",
        "\n",
        "main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KaBmMvWJx9xW"
      },
      "source": [
        ">El bloque if"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "U-Cdqzqxx9xW"
      },
      "outputs": [],
      "source": [
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H1Tnmj55x9xW"
      },
      "source": [
        "> tiene, según Colab, un propósito: «Esta es una construcción estándar de Python. Significa que el código dentro de este bloque if solo se ejecutará cuando el script se ejecute directamente (no cuando se importe como módulo en otro script)».\n",
        "Esto significa que se pueden encadenar diversas funciones encapsuladas en un módulo que puede usarse como herramienta para realizar tareas en otros programas. Por lo tanto, este bloque if indica que este script debe ejecutarse inmediatamente y que no es un módulo que se pueda importar a otro lugar. El símbolo == es el operador de igualdad que se utiliza para comparaciones. Por el contrario, el símbolo = se utiliza para asignar valores a variables.\n",
        "\n",
        "> **Ejercicio.** Visite la página web\n",
        ">>\n",
        ">> https://www.w3schools.com/python/default.asp\n",
        ">>\n",
        ">> que ofrece un tutorial interactivo gratuito de Python. En la columna izquierda, hay una lista de lecciones. Seleccione funciones de Python y disfrute ejecutando in situ los programas propuestos, acompañados de explicaciones claras y concisas. Este sitio se denominará w3.\n",
        "\n",
        "# LA FRECUENCIA RELATIVA\n",
        "\n",
        "*La frecuencia relativa de caras es el número total de caras dividido entre el número de ensayos.* Por lo tanto, la frecuencia relativa solo se puede calcular al final del experimento. Esta tarea se puede simular de diferentes maneras. Elijamos una que facilite la organización: recopilamos los resultados de cada lanzamiento en una caja y, al terminar, contamos el número de caras y calculamos la frecuencia relativa.\n",
        "\n",
        "Python tiene varios tipos de cajas. Una caja de propósito general es el *array*, denotado por `[]`, que contiene una lista ordenada de objetos separados por una coma. Los objetos pueden ser números, letras, palabras, oraciones o entidades más complejas.\n",
        "\n",
        "> **Ejemplo.** En el siguiente programa, los resultados de lanzar una moneda se guardan en el array `results`:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8_HVUITHx9xX"
      },
      "outputs": [],
      "source": [
        "# Program headsProportion.py\n",
        "import random\n",
        "\n",
        "num_flips = 7;\n",
        "\n",
        "def coin_flip():\n",
        "    \"\"\"Simulates a single coin flip.\"\"\"\n",
        "    return random.choice([\"Heads\", \"Tails\"])\n",
        "\n",
        "def simulate_flips(num_flips):\n",
        "    \"\"\"Simulates multiple coin flips, \"\"\"\n",
        "    \"\"\" prints the number of heads and their proportion.\"\"\"\n",
        "    # Semantic respectful printing:\n",
        "    # begin with f and suround variables with curly braces\n",
        "    print(f\"Number of flips = {num_flips}\")\n",
        "    results = [] # This is a void array\n",
        "    for _ in range(num_flips):\n",
        "        # append a new flip at the end of the array,\n",
        "        results.append(coin_flip())\n",
        "    print(f\"Results = {results}\")\n",
        "    number_of_heads = results.count(\"Heads\")\n",
        "    # Semantic respectful printing:\n",
        "    # begin with f and suround variables with curly braces\n",
        "    print(f\"head_count =  {number_of_heads}\")\n",
        "    proportion_of_heads = number_of_heads / num_flips\n",
        "    # Print the proportion rounding to 2 decimal places\n",
        "    print(f\"proportion of heads = + {proportion_of_heads:.2f}\")\n",
        "\n",
        "def main():\n",
        "    simulate_flips(num_flips)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QTRv3T_Fx9xX"
      },
      "source": [
        "> **Ejercicio.** Ejecuta el programa. La expresión .2f es un especificador de formato. Para comprobar su función, cámbiala a .3f o .4f.\n",
        "\n",
        ">> **Respuesta.** El especificador .7f después de un número decimal o real indica que debe redondearse a una precisión de 7 decimales.\n",
        ">>\n",
        ">> Python utiliza varios tipos de números, que se distinguen por el coste de memoria que requiere su almacenamiento. Tenemos enteros, como 3 y 7, y reales, como 4,5 o -3,231. Los reales también se denominan números de coma flotante.\n",
        "\n",
        "# LA TENDENCIA HACIA UNA PROBABILIDAD\n",
        "\n",
        "Nuestro objetivo en esta sección es comprobar la idea de que la frecuencia relativa debe tender a acercarse a un límite, y necesitamos saber si ese límite es la probabilidad predefinida.\n",
        "\n",
        "> **Ejemplo.** Lanzamos una moneda un número predefinido de veces y calculamos la frecuencia relativa de caras. Aumentamos el número de lanzamientos en uno y calculamos la frecuencia relativa de caras. Esto se repite un cierto número de veces para detectar una tendencia, si la hay. El código, en modo de prueba, es el siguiente:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cv4hSYEtx9xY"
      },
      "outputs": [],
      "source": [
        "#  Program headsProportionTendency.py\n",
        "import random\n",
        "\n",
        "num_experiments = 5\n",
        "\n",
        "def coin_flip():\n",
        "    \"\"\"Simulates a single coin flip.\"\"\"\n",
        "    return random.choice([\"Heads\", \"Tails\"])\n",
        "\n",
        "def simulate_flips(num_flips):\n",
        "    \"\"\"Simulates multiple coin flips, \"\"\"\n",
        "    \"\"\" prints the number of heads and their proportion.\"\"\"\n",
        "    # Semantic respectful printing:\n",
        "    # begin with f and suround variables with curly braces\n",
        "    print(f\"Number of flips = {num_flips}\")\n",
        "    results = [] #This is an array\n",
        "    for _ in range(num_flips):\n",
        "        # append a new flip at the end of the array,\n",
        "        results.append(coin_flip())\n",
        "    return results\n",
        "\n",
        "def calculate_tendency(num_experiments):\n",
        "    \"\"\"The number of flips is increased one by one  \"\"\"\n",
        "    \"\"\"from 1 to num_experiments and  \"\"\"\n",
        "    \"\"\"the relative frequency of heads is calculated.\"\"\"\n",
        "    num_flips = 1;\n",
        "    for _ in range(num_experiments):\n",
        "        results = simulate_flips(num_flips)\n",
        "        print(f\"Results = {results}\")\n",
        "        number_of_heads = results.count(\"Heads\")\n",
        "        # Semantic respectful printing:\n",
        "        # begin with f and suround variables with curly braces\n",
        "        print(f\"head_count =  {number_of_heads}\")\n",
        "        proportion_of_heads = number_of_heads / num_flips\n",
        "        # Print the proportion rounding to 2 decimal places\n",
        "        print(f\"proportion of heads = + {proportion_of_heads:.2f}\")\n",
        "        num_flips += 1\n",
        "\n",
        "def main():\n",
        "    calculate_tendency(num_experiments)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2djoGJfkx9xY"
      },
      "source": [
        "> **Ejercicio.** Ejecuta el código y comprueba si es correcto.\n",
        "\n",
        ">> **Respuesta.** El código funciona según lo prometido: calcula la frecuencia relativa de caras para un número creciente de lanzamientos de 1 a 5 y reporta los resultados.\n",
        "\n",
        "## Visualización de resultados\n",
        "\n",
        "Tras ver cómo funciona el programa anterior y determinar su correcto funcionamiento, podemos programar un informe de una lista de valores sucesivos de la frecuencia relativa a medida que aumenta el número de ensayos. La buena noticia es que esta lista se puede dibujar en Python muy fácilmente. Para aprender cómo hacerlo, visitamos la página de W3, buscamos en la columna izquierda la lección sobre Gráficos, encontramos allí una sección titulada «Python Matplotlib», revisamos su material y enseguida encontramos lo que necesitábamos: cómo dibujar los valores de la lista en un array.\n",
        "\n",
        "> **Ejemplo** La lección ofrecida por w3 se implementó de la siguiente manera:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cJbvjM_Hx9xZ"
      },
      "outputs": [],
      "source": [
        "#  Program relativeFrequencyTendency.py\n",
        "# Calculates the tendency of the relative frequency of heads\n",
        "# when a coin is flipped an increasing number of times.\n",
        "# Results are plotted.\n",
        "\n",
        "\n",
        "import random\n",
        "\n",
        "num_experiments = 5\n",
        "\n",
        "def coin_flip():\n",
        "    \"\"\"Simulates a single coin flip.\"\"\"\n",
        "    return random.choice([\"Heads\", \"Tails\"])\n",
        "\n",
        "def simulate_flips(num_flips):\n",
        "    \"\"\"Simulates multiple coin flips, \"\"\"\n",
        "    \"\"\" prints the number of heads and their proportion.\"\"\"\n",
        "    # Semantic respectful printing:\n",
        "    # begin with f and suround variables with curly braces\n",
        "    print(f\"Number of flips = {num_flips}\")\n",
        "    results = [] #This is an array\n",
        "    for _ in range(num_flips):\n",
        "        # append a new flip at the end of the array,\n",
        "        results.append(coin_flip())\n",
        "    return results\n",
        "\n",
        "def calculate_tendency(num_experiments):\n",
        "    # Calculates the tendency of\n",
        "    # the realtive frequency of heads\n",
        "    # when the number of flips grows from 1 to num_experiments\n",
        "    num_flips = 1;\n",
        "    print(f\"Number of experiments = {num_experiments}\")\n",
        "    print(f\"Number of flips per experiment = {num_flips}\")\n",
        "    relative_frequencies = []\n",
        "    for _ in range(num_experiments):\n",
        "        results = simulate_flips(num_flips)\n",
        "        print(f\"Results = {results}\")\n",
        "        number_of_heads = results.count(\"Heads\")\n",
        "        # Semantic respectful printing:\n",
        "        # begin with f and suround variables with curly braces\n",
        "        print(f\"head_count =  {number_of_heads}\")\n",
        "        proportion_of_heads = number_of_heads / num_flips\n",
        "        relative_frequencies.append(proportion_of_heads)\n",
        "        # Print the proportion rounding to 2 decimal places\n",
        "        # The formatting expression \\n creates a void line to easy reading\n",
        "        print(f\"proportion of heads =  {proportion_of_heads:.2f} \\n\")\n",
        "        num_flips += 1\n",
        "    return relative_frequencies\n",
        "\n",
        "def draw_tendency(relative_frequencies):\n",
        "    import matplotlib.pyplot as plt\n",
        "    plt.plot(relative_frequencies)\n",
        "\n",
        "def main():\n",
        "    relative_frequencies = calculate_tendency(num_experiments)\n",
        "    draw_tendency(relative_frequencies)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QF_qphvUx9xZ"
      },
      "source": [
        "> **Ejercicio.** Ejecuta el programa anterior y verifica que todo esté correcto.\n",
        "\n",
        "> **Respuesta.** Todo está correcto.\n",
        "\n",
        "> **Ejercicio.** Dado que tenemos motivos suficientes para creer que el programa es correcto, adapte el programa anterior para obtener los resultados de una simulación con muchos experimentos, digamos 7000. ¿Consideras que la frecuencia relativa muestra una tendencia, y en qué medida?\n",
        "\n",
        ">> **Respuesta.** Se silenciaron las instrucciones para imprimir la mayoría de los mensajes en el programa anterior. Investigamos en w3 cómo dibujar una línea horizontal roja que represente el límite esperado de la frecuencia relativa de caras, que debe ser 0,5. El código es el siguiente:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "K3RJQ9Ehx9xa"
      },
      "outputs": [],
      "source": [
        "#  Program relativeFrequencyTendency2.py\n",
        "# Draws the tendency of the relative frequency of heads\n",
        "# when a coin is flipped an increasing number of times.\n",
        "\n",
        "import random\n",
        "\n",
        "num_experiments = 7000\n",
        "\n",
        "def coin_flip():\n",
        "    \"\"\"Simulates a single coin flip.\"\"\"\n",
        "    return random.choice([\"Heads\", \"Tails\"])\n",
        "\n",
        "def simulate_flips(num_flips):\n",
        "    \"\"\"Simulates multiple coin flips, \"\"\"\n",
        "    \"\"\" prints the number of heads and their proportion.\"\"\"\n",
        "    # Semantic respectful printing:\n",
        "    # begin with f and suround variables with curly braces\n",
        "    # print(f\"Number of flips = {num_flips}\")\n",
        "    results = [] #This is an array\n",
        "    for _ in range(num_flips):\n",
        "        # append a new flip at the end of the array,\n",
        "        results.append(coin_flip())\n",
        "    return results\n",
        "\n",
        "def calculate_tendency(num_experiments):\n",
        "    \"\"\"Calculates the tendency of\"\"\"\n",
        "    \"\"\"the realtive frequency of heads\"\"\"\n",
        "    \"\"\"when the number of flips grows from 1 to num_experiments\"\"\"\n",
        "    num_flips = 1;\n",
        "    relative_frequencies = []\n",
        "    for _ in range(num_experiments):\n",
        "        results = simulate_flips(num_flips)\n",
        "        # print(f\"Results = {results}\")\n",
        "        number_of_heads = results.count(\"Heads\")\n",
        "        # Semantic respectful printing:\n",
        "        # begin with f and suround variables with curly braces\n",
        "        # print(f\"head_count =  {number_of_heads}\")\n",
        "        proportion_of_heads = number_of_heads / num_flips\n",
        "        relative_frequencies.append(proportion_of_heads)\n",
        "        # Print the proportion rounding to 2 decimal places\n",
        "        # The formatting expression \\n creates a void line to easy reading\n",
        "        # print(f\"proportion of heads = + {proportion_of_heads:.2f} \\n\")\n",
        "        num_flips += 1\n",
        "    return relative_frequencies\n",
        "\n",
        "def draw_tendency(relative_frequencies):\n",
        "    import matplotlib.pyplot as plt\n",
        "    import numpy as np\n",
        "    # The tendency of relative frequencies is drawn\n",
        "    plt.plot(relative_frequencies)\n",
        "    plt.xlabel(\"Number of flips\")\n",
        "    plt.ylabel(\"Relative frequency\")\n",
        "    plt.title(\"Tendency of the relative frequency\")\n",
        "    plt.grid(True)\n",
        "\n",
        "    # Red horizontal line representing the expected limit = 0.5\n",
        "    xpoints = np.array([0, 7000])\n",
        "    ypoints = np.array([0.5, 0.5])\n",
        "    plt.plot(xpoints, ypoints, c = 'r')\n",
        "    plt.show()\n",
        "\n",
        "def main():\n",
        "    print(f\"Number of experiments = {num_experiments}\")\n",
        "    print(\"Tendency of the relative frequency\")\n",
        "    print(f\"when the number of flips grows from 1 to {num_experiments}\")\n",
        "    relative_frequencies = calculate_tendency(num_experiments)\n",
        "    draw_tendency(relative_frequencies)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dBUNvIJWx9xa"
      },
      "source": [
        ">> El gráfico muestra claramente que la incertidumbre disminuye al aumentar el número de intentos. Los resultados tienden a acumularse cerca de la línea roja que marca la probabilidad de cara como 0,5. Sin embargo, la convergencia a este límite es muy lenta, y la incertidumbre parece no tener fin. A pesar de ello, nos alegra mucho que la tendencia al valor esperado nos muestre que Python cuenta con un buen generador de números pseudoaleatorios.\n",
        "\n",
        "**Conclusión.** Tenemos motivos para creer que la frecuencia relativa de caras tiene una tendencia que se reafirma al aumentar el número de intentos por ronda. Parece converger muy lentamente hacia la probabilidad. De todas maneras, identifiquemos la probabilidad con la frecuencia relativa cuando el número de ensayos es casi infinito, digamos, 10000.\n",
        "\n",
        "> **Desafío.** El programa `relativeFrequencyTendency2.py` es muy exigente porque realiza 7000 rondas, en las que el número de lanzamientos por ronda aumenta de 1 a 7000. Investigue o invente una manera de que esto sea factible con un bajo esfuerzo computacional, por ejemplo, calculando solo una muestra de valores. Implemente su idea.\n",
        "\n",
        "> **Investigación.** Resuelva la siguiente objeción: la frecuencia relativa no converge a la probabilidad. En cambio, la frecuencia relativa oscila alrededor de la probabilidad y se cansa muy lentamente, pero nunca se agota.\n",
        "\n",
        "# LA TENDENCIA HACIA UNA DISTRIBUCIÓN\n",
        "\n",
        "Hemos observado que la frecuencia relativa tiende a converger hacia un límite. Cuando el modelo es correcto y la fuente de números pseudoaleatorios es aceptable, el límite coincide con la probabilidad. Si aceptamos esto, podemos ir un paso más allá.\n",
        "\n",
        "Imaginemos que trabajamos con un número constante de monedas o ensayos por ronda, digamos 20. Si hacemos un experimento, podríamos obtener 14 caras. Pero si repetimos el experimento, es casi seguro que no obtendremos 14. ¿Podemos hacer Ciencia en estas circunstancias? Sí, podemos. La razón es que existe una tendencia de la siguiente naturaleza:\n",
        "\n",
        "Contemos el número de veces que obtenemos 14 caras al repetir el experimento varias veces, que podrían ser 10000, cada vez con 20 monedas. A partir de ese número, podemos calcular la frecuencia relativa de 14. Pero las frecuencias relativas tienden a un límite. Por lo tanto, predecimos que para cada k entre 0 y 20, la frecuencia relativa de obtener k caras tiende a un límite. Por eso, obtenemos una excelente predicción: El gráfico resultante, que representa la tendencia de cada frecuencia relativa de obtener k caras, debe tender a una forma límite denominada Distribución Binomial.\n",
        "\n",
        "Nuestro siguiente objetivo es estimar dicha distribución. Utilizaremos un número grande, pero finito, de rondas, por lo que esperamos que nuestra estimación sea precisa. Para empezar, conozcamos una sorprendente posibilidad de la tecnología moderna.\n",
        "\n",
        "## Desarrollo automático de código\n",
        "\n",
        "Durante el desarrollo de nuestros programas anteriores, hemos contado con la asistencia continua de Codey, una de las IA detrás de Colab. Ofrece sugerencias, y casi todas son oportunas y correctas. De hecho, hoy en día es posible solicitar a servicios de IA que desarrollen código con requisitos específicos.\n",
        "\n",
        "> **Ejemplo.** Solicitamos a Google:\n",
        ">>\n",
        ">> chatgpt código de Python para una simulación con monedas\n",
        ">>\n",
        ">> ChatGPT no apareció; en su lugar, Gemini respondió con el siguiente código:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "HxulrlgUx9xa"
      },
      "outputs": [],
      "source": [
        "#  Program coinsByGemini.py\n",
        "\n",
        "import random\n",
        "\n",
        "def coin_flip():\n",
        "    \"\"\"Simulates a single coin flip.\"\"\"\n",
        "    return random.choice([\"Heads\", \"Tails\"])\n",
        "\n",
        "def simulate_flips(num_flips):\n",
        "    \"\"\"Simulates multiple coin flips and returns a list of results.\"\"\"\n",
        "    results = []\n",
        "    for _ in range(num_flips):\n",
        "        results.append(coin_flip())\n",
        "    return results\n",
        "\n",
        "def count_outcomes(results):\n",
        "    \"\"\"Counts the number of heads and tails in a list of results.\"\"\"\n",
        "    heads_count = results.count(\"Heads\")\n",
        "    tails_count = len(results) - heads_count\n",
        "    return heads_count, tails_count\n",
        "\n",
        "def print_results(results):\n",
        "    \"\"\"Prints the individual results of coin flips.\"\"\"\n",
        "    print(\"Individual coin flip results:\")\n",
        "    for result in results:\n",
        "        print(result)\n",
        "\n",
        "def display_summary(heads_count, tails_count):\n",
        "    \"\"\"Displays the summary of the simulation.\"\"\"\n",
        "    print(\"\\nSimulation Summary:\")\n",
        "    print(f\"Number of heads: {heads_count}\")\n",
        "    print(f\"Number of tails: {tails_count}\")\n",
        "    total_flips = heads_count + tails_count\n",
        "    if total_flips > 0:\n",
        "        print(f\"Percentage of heads: {heads_count / total_flips * 100:.2f}%\")\n",
        "        print(f\"Percentage of tails: {tails_count / total_flips * 100:.2f}%\")\n",
        "\n",
        "def main():\n",
        "    \"\"\"Main function to run the simulation.\"\"\"\n",
        "    try:\n",
        "        num_flips = int(input(\"Enter the number of coin flips: \"))\n",
        "        if num_flips <= 0:\n",
        "            print(\"Please enter a positive number of flips.\")\n",
        "            return\n",
        "\n",
        "        results = simulate_flips(num_flips)\n",
        "        print_results(results)\n",
        "        heads_count, tails_count = count_outcomes(results)\n",
        "        display_summary(heads_count, tails_count)\n",
        "\n",
        "    except ValueError:\n",
        "        print(\"Invalid input. Please enter an integer.\")\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xvqIoDjRx9xb"
      },
      "source": [
        ">>Gemini añadió al final: \"Las respuestas de la IA pueden incluir errores\". También pidió evaluar su respuesta. Esto implica que debemos ejecutar el código para ver qué hace.\n",
        "\n",
        "> **Ejercicio.** Ejecuta el código anterior y pide a Colab que lo explique.\n",
        "\n",
        ">> **Respuesta.** El código funciona de maravilla, informando los resultados de un experimento con la cantidad de monedas especificada por el usuario en un cuadro de entrada. La salida está estructurada, y cada resultado es correcto y está identificado con precisión.\n",
        "\n",
        "> **Ejercicio.** Ejecute el código anterior de nuevo, pero esta vez escriba la palabra \"siete\" en lugar del número 7. ¿Qué sucede y por qué?\n",
        "\n",
        ">> **Respuesta.** El programa produce el siguiente output: \"Entrada no válida. Por favor, introduzca un entero\". Esto se debe al bloque de código que comienza con \"excepto ValueError:\". Este es un estilo de programación que predica que los programas deben aceptar cualquier tipo de usuario, especialmente a los principiantes.\n",
        "\n",
        "\n",
        "> **Ejemplo.** Visitamos la página web de Gemini y le pedimos que desarrollara el código para una simulación con monedas, incluyendo algunas estadísticas. Para ello, le dimos la siguiente instrucción:\n",
        ">>\n",
        ">> ¡Hola, Gemini! Por favor, ayúdame con el código Python para una simulación con monedas, repeticiones y estadísticas.\n",
        ">>\n",
        ">> Gemini respondió pidiendo más detalles y aportó algunas ideas. Así que las usamos para ser más específicos:\n",
        ">>\n",
        ">> Número de monedas = 10, número de repeticiones = 100, estadísticas del número total de caras en todas las repeticiones, la proporción de caras y la distribución de caras.\n",
        ">>\n",
        ">> Después de dos segundos, Gemini reportó el siguiente código:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TSwjyiG2x9xb"
      },
      "outputs": [],
      "source": [
        "#  Program headsCountByGemini.py\n",
        "# Simulates the binomial Distribution with\n",
        "# p = 0.5, n = num_coins_per_round.\n",
        "\n",
        "\n",
        "import random\n",
        "from collections import Counter\n",
        "\n",
        "# Parameters for the simulation\n",
        "num_coins_per_round = 10\n",
        "num_repetitions = 100\n",
        "\n",
        "# Simulate coin flips\n",
        "results = []\n",
        "for _ in range(num_repetitions):\n",
        "    heads_in_round = 0\n",
        "    for _ in range(num_coins_per_round):\n",
        "        # 0 for tails, 1 for heads\n",
        "        if random.choice([0, 1]) == 1:\n",
        "            heads_in_round += 1\n",
        "    results.append(heads_in_round)\n",
        "\n",
        "# Calculate statistics\n",
        "total_heads = sum(results)\n",
        "proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "heads_distribution = Counter(results)\n",
        "\n",
        "# Print the results\n",
        "print(f\"Simulation of {num_repetitions} rounds with {num_coins_per_round} coins per round:\")\n",
        "print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "print(\"Heads distribution\") #Added by the User\n",
        "print(heads_distribution) #Added by the User\n",
        "print(\"\\nDistribution of heads per round:\")\n",
        "# Sort the distribution for better readability\n",
        "sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    print(f\"  {num_heads} heads: {count} times\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ocNO9Y1xx9xc"
      },
      "source": [
        "> ¿Debemos preocuparnos por ejecutar el código? ¡Para nada! Gemini lo ejecutó y reportó los siguientes resultados:\n",
        ">\n",
        ">> Simulación de 100 pruebas con 10 monedas por prueba:\n",
        ">>\n",
        ">> Número total de caras en todas las pruebas: 502\n",
        ">>\n",
        ">> Proporción de caras en todas las pruebas: 0,5020\n",
        ">>\n",
        ">> Distribución de caras por prueba:\n",
        ">>\n",
        ">> 1 cara: 2 veces\n",
        ">>\n",
        ">> 2 caras: 2 veces\n",
        ">>\n",
        ">> 3 caras: 11 veces\n",
        ">>\n",
        ">> 4 caras: 23 veces\n",
        ">>\n",
        ">> 5 caras: 21 veces\n",
        ">>\n",
        ">> 6 caras: 25 veces\n",
        ">>\n",
        ">> 7 caras: 12 veces\n",
        ">>\n",
        ">> 8 caras: 4 veces\n",
        ">>\n",
        ">>\n",
        ">>Curiosamente, Gemini no añadió la advertencia de que puede cometer errores. En su lugar, pidió al usuario que evaluara su trabajo.\n",
        "\n",
        "> **Ejercicio.** Resume lo que hace el código y evalúalo.\n",
        "\n",
        ">> **Respuesta.** Este código simula lanzar 10 monedas por ronda y completar 100 rondas. Luego, calcula las estadísticas deseadas: el número total de caras, la proporción de caras y la distribución de la frecuencia con la que ocurre un número dado de caras. La salida está estructurada, cada elemento está identificado y el número de caras en la tabla suma 100. El código carece del formalismo main().\n",
        "\n",
        "> Una parte del código no nos quedó clara, así que la copiamos aparte:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "cj-GCU7ax9xc"
      },
      "outputs": [],
      "source": [
        "# Sort the distribution for better readability\n",
        "sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    print(f\"  {num_heads} heads: {count} times\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZIbC4M53x9xc"
      },
      "source": [
        "> **Ejercicio.** Deja que Colab explique este *fragmento*. ¿Qué hace este código?\n",
        "\n",
        "> **Respuesta.** El programa `coinsStatisticsByGemini.py` repite un experimento 100 veces. Cada experimento consiste en lanzar una moneda 10 veces y registrar el número de caras. Los resultados van de 0 a 10. A continuación, el programa cuenta el número de veces que sale cada número específico de caras. Esto genera una tabla desordenada con pares de números; por ejemplo, 5 caras salieron 12 veces. Para ordenar la tabla resultante, `heads_distribution` se ordena por el número de caras en orden creciente, y el resultado se ubica en un `dictionary`, una tabla con pares, cuyo primer valor es el número de caras y el segundo es el número de veces que salió esa misma cara.\n",
        "\n",
        "## Añadiendo gráficos\n",
        "\n",
        "Las estadísticas entran por los ojos. Por lo tanto, añadamos gráficos al código anterior.\n",
        "\n",
        "> **Ejemplo**. Es obligatorio dibujar la tabla de distribución de caras reportada por el programa anterior. Así que le preguntamos a Google: ¿Cómo graficar una tabla en Python? Google respondió con una explicación y un fragmento de código. Lo observamos y decidimos intentarlo de nuevo. Le preguntamos a Google: ¿Cómo graficar una función matemática en Python? Google respondió con una nueva variante de código que preferimos. El código era:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "sGXI1jc0x9xd"
      },
      "outputs": [],
      "source": [
        "# Program graphOfMathFunctionByGemini.py\n",
        "# how to graph in Python a math function?\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# 1. Define the mathematical function\n",
        "def my_function(x):\n",
        "    return np.sin(x) + np.cos(x) # Example: a trigonometric function\n",
        "\n",
        "# 2. Generate x-values\n",
        "x_values = np.linspace(0, 2 * np.pi, 200) # 200 points from 0 to 2*pi\n",
        "\n",
        "# 3. Calculate corresponding y-values\n",
        "y_values = my_function(x_values)\n",
        "\n",
        "# 4. Plot the function\n",
        "plt.plot(x_values, y_values, label=\"sin(x) + cos(x)\")\n",
        "\n",
        "# 5. Add labels, title, and legend\n",
        "plt.xlabel(\"X-axis\")\n",
        "plt.ylabel(\"Y-axis\")\n",
        "plt.title(\"Graph of a Trigonometric Function\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "PNeXc9Gjx9xd"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "raSfRlBXx9xd"
      },
      "source": [
        "Ejercicio, ejecuta el código y deja que Colab lo explique.\n",
        "\n",
        ">> **Respuesta.** Ejecutamos el código y nos causó admiración. La idea básica para dibujar una función o una tabla es colocar los valores de entrada en un vector y los valores de salida en otro, y usar bibliotecas importadas para trazar el gráfico. Ten en cuenta que los datos de entrada no se proporcionan mediante un array de pares de coordenadas, sino que todas las coordenadas X corresponden a un vector y todas las coordenadas Y a otro. Esto significa que la herramienta de gráficos debe construir los pares por sí misma.\n",
        "\n",
        "> **Ejemplo.** Utilizando el desarrollo de Gemini, añadimos el código para un gráfico al programa `coinsStatisticsByGemini.py` de la siguiente manera:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LkgicS-Hx9xe"
      },
      "outputs": [],
      "source": [
        "#  Program headsCountByGemini2.py\n",
        "\n",
        "#Libraries and local rename\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "\n",
        "# Parameters for the simulation\n",
        "num_coins_per_round = 10\n",
        "num_repetitions = 10000\n",
        "\n",
        "# Simulate coin flips\n",
        "results = []\n",
        "for _ in range(num_repetitions):\n",
        "    heads_in_round = 0\n",
        "    for _ in range(num_coins_per_round):\n",
        "        # 0 for tails, 1 for heads\n",
        "        if random.choice([0, 1]) == 1:\n",
        "            heads_in_round += 1\n",
        "    results.append(heads_in_round)\n",
        "\n",
        "# Calculate statistics\n",
        "total_heads = sum(results)\n",
        "proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "heads_distribution = Counter(results)\n",
        "\n",
        "x_values = []\n",
        "y_values = []\n",
        "\n",
        "# Print the results\n",
        "print(f\"Simulation of {num_repetitions} rounds \")\n",
        "print(f\"with {num_coins_per_round} coins per round:\")\n",
        "print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "print(\"\\nDistribution of heads per round:\")\n",
        "# Sort the distribution for better readability\n",
        "sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    x_values.append(num_heads)\n",
        "    y_values.append(count)\n",
        "    print(f\"  {num_heads} heads: {count} times\")\n",
        "\n",
        "# Plot the function\n",
        "plt.plot(x_values, y_values, label=\"Heads_distribution\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"Number of heads\")\n",
        "plt.ylabel(\"Count\")\n",
        "plt.title(\"Graph of heads counts\")\n",
        "plt.grid(True)\n",
        "plt.legend(\"Heads count\")\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vcqrokqqx9xv"
      },
      "source": [
        "> **Ejercicio.** Ejecute el código con las modificaciones pertinentes para observar una tendencia al aumentar el número de experimentos.\n",
        "\n",
        ">> **Respuesta.** Con 100 experimentos, los datos se agruparon en torno a una distribución de tipo montaña. Para comprobar si se trata de una tendencia, ejecutamos el código con 1000 experimentos. La tendencia se reafirmó: apareció una montaña casi simétrica con una moda de cinco. Esto concuerda con la proporción calculada de caras, es decir, 0,493. Aparecieron los valores extremos 1, 9 y 10, pero no el 0. Aparecieron montañas casi perfectamente simétricas cuando el número de repeticiones se estableció en 10 000. En este caso, aparecieron todos los valores extremos. La proporción observada de caras fue de 0,4995. Esto se acerca bastante a 0,5, que es la proporción esperada de caras cuando programamos una elección aleatoria entre 1 y 0, o sea entre cara y sello, o cara y cruz. En conclusión, observamos dos tendencias. Primero: la proporción observada de caras tiende a 0,4995, y segundo, la silueta de la montaña que describe la distribución del número de caras tiende a ser más simétrica y a tener la forma de una campana que se desvanece en los valores extremos a ambos lados de la campana, pero sin llegar a 0.\n",
        "\n",
        "> **Conclusión.** Cuando contamos el número de caras al lanzar n monedas, dado que la probabilidad de cara es p, la frecuencia relativa de obtener k caras tiende a un límite. El gráfico general, con todos los k de 0 a n, tiende a una forma límite, es decir, una campana.\n",
        "\n",
        "Nuestro siguiente objetivo es estimar dicha distribución. El problema es que parecemos estar congelados en p = 0,5. Así que, mostremos cómo obtener la libertad.\n",
        "\n",
        "\n",
        "## Trabajando con probabilidades distintas de 0.5\n",
        "\n",
        "\n",
        "Si solo sabemos simular una moneda justa, podemos manipular la probabilidad de cara con un truco sencillo.\n",
        "\n",
        ">> **Ejemplo.** En los programas anteriores, identificamos cara con 1 y cruz con 0, por lo que se simuló una moneda justa eligiendo aleatoriamente entre cara y cruz, o entre 1 y 0. Para manipular la probabilidad de cara, en lugar de elegir aleatoriamente entre 0 y 1, elijamos aleatoriamente entre 0, 1 y 1. Así, asignamos a cara, representada por 1, una probabilidad de 2/3 = 0,666 y a cruz, 1/3 = 0,333... El código es el siguiente:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q_oPPgaSx9xw"
      },
      "outputs": [],
      "source": [
        "#  Program coinsProbOfHeadsTwoThirds.py\n",
        "\n",
        "# Libraries and local rename\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "\n",
        "# Parameters for the simulation\n",
        "num_coins_per_round = 20\n",
        "num_repetitions = 10000\n",
        "\n",
        "# Simulate coin flips\n",
        "results = []\n",
        "for _ in range(num_repetitions):\n",
        "    heads_in_round = 0\n",
        "    for _ in range(num_coins_per_round):\n",
        "        # 0 for tails, 1 for heads\n",
        "        if random.choice([0, 1, 1]) == 1:\n",
        "            heads_in_round += 1\n",
        "    results.append(heads_in_round)\n",
        "\n",
        "# Calculate statistics\n",
        "total_heads = sum(results)\n",
        "proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "heads_distribution = Counter(results)\n",
        "\n",
        "# Arrays to keep values to be graphed\n",
        "x_values = []\n",
        "y_values = []\n",
        "\n",
        "# Print the results\n",
        "print(\"Heads is 1 in a random choice among 0, 1, 1 \")\n",
        "print(\"So, the probability of heads is 2/3 = 0.666... \")\n",
        "print(\"and that of tails is 1/3 = 0.333...\")\n",
        "print(f\"Simulation of {num_repetitions} rounds \")\n",
        "print(f\"with {num_coins_per_round} coins per round:\")\n",
        "print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "print(\"\\nDistribution of heads per round:\")\n",
        "# Sort the distribution for better readability\n",
        "sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    x_values.append(num_heads)\n",
        "    y_values.append(count)\n",
        "    print(f\"  {num_heads} heads: {count} times\")\n",
        "\n",
        "# Plot the function\n",
        "plt.plot(x_values, y_values, label=\"Heads_distribution\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"Number of heads\")\n",
        "plt.ylabel(\"Count\")\n",
        "plt.title(\"Graph of a heads distribution\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v9z-Mu4_x9xw"
      },
      "source": [
        "Dado que la probabilidad de cara es de 0,666..., esperamos un poco más de 13 caras entre 20 lanzamientos. La moda del gráfico se ajusta bastante a esta expectativa.\n",
        "\n",
        "> **Ejercicio.** Ejecute el programa variando el número de experimentos para descubrir una tendencia.\n",
        "\n",
        ">> **Respuesta.** La tendencia era una montaña asimétrica con un pico o moda en 7 para 10 monedas y 13,5 para 20.\n",
        "\n",
        "> **Investigación.** Nuestro método para ejecutar simulaciones con una probabilidad de cara distinta de 0,5 es muy potente, pero muy aburrido. Entonces, la pregunta es: ¿cómo se simulan probabilidades arbitrarias en Python?\n",
        "\n",
        "# LA DISTRIBUCIÓN BINOMIAL\n",
        "\n",
        "Con exploraciones anteriores, tuvimos la impresión de que la silueta de la distribución de caras de las monedas justas tiende a encajar en una campana que es simétrica y que tiende a cero lateralmente. Así pues, veamos qué podemos hacer para convencernos de que esta impresión es correcta y de que es cierto que la distribución del número de caras tiende a un límite cuando aumenta el número de repeticiones. Este límite se denomina ***Distribución Binomial***.\n",
        "\n",
        "> **Ejemplo.** Propongamos el siguiente código para abordar el problema de la convergencia de la distribución de k caras:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aHUBy2Rvx9xw"
      },
      "outputs": [],
      "source": [
        "#  Program tendencyToBinomial.py\n",
        "\n",
        "# Libraries and local rename\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "\n",
        "# Parameters for the simulation\n",
        "num_coins_per_round = 2\n",
        "flipping_numbers_to_be_sampled = [1, 10, 100, 1000, 10000]\n",
        "\n",
        "\n",
        "# Simulate coin flips\n",
        "# Returns an array with the number of heads per round\n",
        "def simulate_coin_flips(num_coins_per_round, num_repetitions):\n",
        "    results = []\n",
        "    for _ in range(num_repetitions):\n",
        "        heads_in_round = 0\n",
        "        for _ in range(num_coins_per_round):\n",
        "            # 0 for tails, 1 for heads\n",
        "            if random.choice([0, 1]) == 1:\n",
        "                heads_in_round += 1\n",
        "        results.append(heads_in_round)\n",
        "    return results\n",
        "\n",
        "\n",
        "\n",
        "# Calculate statistics\n",
        "# Returns the sorted distribution of heads\n",
        "# as an array with num_heads and another with the corresponding  count\n",
        "def calculate_statistics(results, num_coins_per_round, num_repetitions):\n",
        "    total_heads = sum(results)\n",
        "    proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "    heads_distribution = Counter(results)\n",
        "\n",
        "    # Arrays to keep values\n",
        "    num_heads_values = []\n",
        "    count_values = []\n",
        "    # Print the results\n",
        "    print(f\"Simulation of {num_repetitions} rounds \")\n",
        "    print(f\"with {num_coins_per_round} coins per round:\")\n",
        "    print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "    print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "    print(\"\\nDistribution of heads:\")\n",
        "    # Sort the distribution for better readability\n",
        "    sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "    for num_heads, count in sorted_distribution.items():\n",
        "        relative_frequency = {count/num_repetitions}\n",
        "        print(f\"{num_heads} heads: {count} times,   {relative_frequency} relative frequency\")\n",
        "        num_heads_values.append(num_heads)\n",
        "        count_values.append(count)\n",
        "    return num_heads_values, count_values\n",
        "\n",
        "\n",
        "# Find the observed distribution of the number of heads\n",
        "# for various flip values for a fix number of coins.\n",
        "def find_hyper_distribution(num_coins_per_round):\n",
        "    for num_repetitions in flipping_numbers_to_be_sampled:\n",
        "        print(\"\\n=============================\\n\")\n",
        "        print(f\"Flipping number =  {num_repetitions}\")\n",
        "        results = simulate_coin_flips(num_coins_per_round, num_repetitions)\n",
        "        num_heads_values, count_values = calculate_statistics(results, num_coins_per_round, num_repetitions)\n",
        "\n",
        "def main():\n",
        "    find_hyper_distribution(num_coins_per_round)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "60PiQu22x9xx"
      },
      "source": [
        "> **Ejercicio.** Ejecute el programa `tendencyToBinomial.py` y determine, mediante inspección, si la distribución del recuento de caras, normalizada como frecuencias relativas, se acerca a un límite. Compare sus resultados con la esperanza matemática para el caso con dos monedas. Advertencia: Los resultados de un programa se muestran en una ventana de tamaño limitado. Por lo tanto, si el resultado es demasiado largo, es necesario desplazarse por la ventana para ver todos los resultados publicados.\n",
        "\n",
        ">> **Respuesta.** El resultado muestra que, al aumentar el número de repeticiones, las frecuencias relativas de 0, 1 y 2 caras al lanzar dos monedas tienden a un límite que coincide con la predicción matemática dada por la probabilidad de cara. Aclaremos que estamos considerando el caso en el que caras y cruces son equiprobables.\n",
        ">\n",
        ">> De hecho, para dos monedas, cuando la probabilidad de cara es igual a la de sello, igual a 1/2, tenemos las siguientes 4 posibilidades: cc, cs, sc, ss, donde c y s denotan cara y sello, respectivamente. Como c y s tienen la misma probabilidad y los eventos son independientes, las 4 posibilidades tienen la misma probabilidad, que debe ser $1/4$. Si contamos el número de caras, vemos que caen 2 caras en el caso cc con probabilidad $1/4 = 0.25$, que sale 1 cara en cs y sc con probabilidad total $1/4 + 1/4 = 1/2 = 0.5$, y obtenemos 0 caras en el caso ss con probabilidad $1/4$. Ordenando por el número de caras, esperamos una tabla con frecuencias relativas 0.25, 0.5, 0.25. Vemos que las tablas de frecuencias relativas de la simulación tienden a esta expectativa cuando el número de ensayos crece. Para 10000 ensayos, la tabla final se ajusta bastante bien a esta expectativa matemática. Por lo tanto, podemos decir que la distribución observada de caras tiende a un límite que coincide con la expectativa matemática, la predicción establecida por las probabilidades.\n",
        "\n",
        "Nuestros resultados confirman que la distribución observada de caras tiende a un límite que coincide con la esperanza matemática. Esta se calculó asumiendo que cara y cruz tienen la misma probabilidad y que los eventos son independientes; es decir, que el resultado de un experimento no modifica la frecuencia relativa de ensayos futuros o paralelos. En la jerga oficial, decimos que la esperanza matemática de la distribución de frecuencias relativas es la *Distribución Binomial*, y que este es el límite al que tienden las distribuciones observadas, asumiendo que tenemos un número infinito de ensayos y que la fuente de números aleatorios es perfecta o al menos aceptable.\n",
        "\n",
        "Para apreciar mejor la tendencia de las campanas, grafiquemoslas. Por lo tanto, necesitamos entender cómo crear gráficos de barras 3D en Python. Es especialmente importante saber cómo se deben proporcionar los datos a los procedimientos de representación gráfica. Para crear gráficos 3D, necesitamos trabajar con matrices 2D.\n",
        "\n",
        "> **Ejemplo.** Consultamos en Google sobre matrices 2D y Gemini respondió con el siguiente código:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q_3J-2_kx9xx"
      },
      "outputs": [],
      "source": [
        "#  Program 2D_array.py\n",
        "# By Gemini\n",
        "import numpy as np\n",
        "\n",
        "# Creating a 2D array using NumPy\n",
        "numpy_2d_array = np.array([[1, 2, 3],\n",
        "                            [4, 5, 6],\n",
        "                            [7, 8, 9]])\n",
        "\n",
        "# Accessing elements\n",
        "print(numpy_2d_array[0, 1])  # Accesses the element at row 0, column 1 (value: 2)\n",
        "\n",
        "# Performing operations (example: element-wise addition)\n",
        "array_b = np.array([[10, 11, 12],\n",
        "                    [13, 14, 15],\n",
        "                    [16, 17, 18]])\n",
        "result_array = numpy_2d_array + array_b\n",
        "print(result_array)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PM3VfLTjx9xx"
      },
      "source": [
        "> **Ejercicio.** Ejecuta el código y presta atención a la forma en que se accede a los elementos.\n",
        "\n",
        "> **Respuesta.** Con la biblioteca `numpy`, se accede a los elementos de una matriz 2x2 como en matemáticas comunes, pero se declaran como vectores de vectores.\n",
        "\n",
        "Con esto, pasemos a los gráficos 3D.\n",
        "\n",
        "> **Ejemplo.** Solicitamos a Google:\n",
        ">\n",
        "> examples of 3d bar graphics in Python\n",
        ">\n",
        "> Google corrigió nuestra solicitud a:\n",
        ">>\n",
        ">> examples of 3d bar graphs in Python\n",
        ">>\n",
        ">> Efectivamente, \"graph\" se refiere a datos matemáticos, mientras que \"graphics\" es más general. Gemini mostró el siguiente código y añadió las explicaciones pertinentes."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RBoZ9TSfx9xx"
      },
      "outputs": [],
      "source": [
        "# Program 3dBarChartByGemini.py\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "\n",
        "# Sample data\n",
        "x_data = np.arange(5)\n",
        "print(f\"x_data = {x_data} \\n\")\n",
        "y_data = np.arange(5)\n",
        "print(f\"y_data = {y_data} \\n\")\n",
        "# Random heights for the bars\n",
        "# Real values with max = 10\n",
        "# It is a 5X5 matrix\n",
        "z_heights = np.random.rand(5, 5) * 10\n",
        "print(f\"z_heights = {z_heights} \\n\")\n",
        "\n",
        "# Create a meshgrid for the x and y coordinates of the bars\n",
        "_xx, _yy = np.meshgrid(x_data, y_data)\n",
        "print(f\"_xx = {_xx} \\n\")\n",
        "print(f\"_yy = {_yy} \\n\")\n",
        "x_pos, y_pos = _xx.ravel(), _yy.ravel()\n",
        "print(f\"x_pos = {x_pos} \\n\")\n",
        "print(f\"y_pos = {y_pos} \\n\")\n",
        "z_pos = np.zeros_like(x_pos)  # All bars start at z=0\n",
        "print(f\"z_pos = {z_pos} \\n\")\n",
        "\n",
        "# Define the dimensions of the bars\n",
        "dx = dy = 0.8  # Width and depth of the bars\n",
        "dz = z_heights.ravel() # Heights of the bars\n",
        "print(f\"dz = {dz} \\n\")\n",
        "\n",
        "# Create the 3D plot\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "# Plot the 3D bars\n",
        "ax.bar3d(x_pos, y_pos, z_pos, dx, dy, dz, shade=True)\n",
        "\n",
        "# Set labels and title\n",
        "ax.set_xlabel('X-axis')\n",
        "ax.set_ylabel('Y-axis')\n",
        "ax.set_zlabel('Z-axis (Height)')\n",
        "ax.set_title('Basic 3D Bar Plot')\n",
        "\n",
        "# Display the plot\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C4D5TFvjx9xy"
      },
      "source": [
        "> **Ejercicio.** Ejecute el código y preste atención a la forma de codificar los datos para los procedimientos gráficos.\n",
        "\n",
        ">> **Respuesta.** El código es complejo. Prevemos un gran esfuerzo para adaptarlo a nuestro propósito. Mientras tanto, observamos que el código inventa datos y luego los usa como datos sin procesar para los gráficos. La forma en que los datos deben empaquetarse para que la función de dibujo los pueda entender es una extensión de la de los gráficos 2D: los puntos donde comienzan las barras no se codifican como una terna; en su lugar, todas las coordenadas x de todos los puntos se codifican en el vector, o matriz unidimensional, `x_pos`, todas las coordenadas y en `y_pos`, y todas las coordenadas z en `z_pos`. Además, cada barra tiene una altura que debe declararse como `dz`. El ancho `dx` y la profundidad `dy` de las barras son constantes.\n",
        "\n",
        "> **Ejemplo.** Siguiendo el ejemplo ofrecido por Gemini, proponemos el siguiente programa que grafica la tendencia de la distribución del número de caras hacia la Distribución Binomial:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "wO3UusM7x9xy"
      },
      "outputs": [],
      "source": [
        "#  Program tendencyToBinomialGraph.py\n",
        "\n",
        "# Libraries and local rename\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "\n",
        "\n",
        "# Parameters for the simulation\n",
        "num_coins_per_round = 5\n",
        "flipping_numbers_to_be_sampled = [10, 100, 1000, 10000]\n",
        "\n",
        "\n",
        "# Data for the graph\n",
        "# Sample data\n",
        "x_data = np.arange(num_coins_per_round +1)\n",
        "print(f\"x_data = {x_data} \\n\")\n",
        "numb_flipping_values = len(flipping_numbers_to_be_sampled)\n",
        "print(f\"numb_flipping_values = {numb_flipping_values} \\n\")\n",
        "y_data =  np.arange(numb_flipping_values)\n",
        "print(f\"y_data = {y_data} \\n\")\n",
        "\n",
        "\n",
        "\n",
        "# Create a meshgrid for the x and y coordinates of the bars\n",
        "_xx, _yy = np.meshgrid(x_data, y_data)\n",
        "x_pos, y_pos = _xx.ravel(), _yy.ravel()\n",
        "print(f\"x_pos = {x_pos} \\n\")\n",
        "print(f\"y_pos = {y_pos} \\n\")\n",
        "z_pos = np.zeros_like(x_pos)  # All bars start at z=0\n",
        "z_heights = 1.0 *np.zeros_like(_xx) #z_heights initialization\n",
        "print(f\"_xx = {_xx} \\n\")\n",
        "print(f\"_yy = {_yy} \\n\")\n",
        "print(f\"z_heights = {z_heights} \\n\")\n",
        "\n",
        "\n",
        "# Define the dimensions of the bars\n",
        "dx = dy = 0.6  # Width and depth of the bars\n",
        "\n",
        "# Simulate coin flips\n",
        "# Returns an array with the number of heads per round\n",
        "def simulate_coin_flips(num_coins_per_round, num_repetitions):\n",
        "    results = []\n",
        "    for _ in range(num_repetitions):\n",
        "        heads_in_round = 0\n",
        "        for _ in range(num_coins_per_round):\n",
        "            # 0 for tails, 1 for heads\n",
        "            if random.choice([0, 1]) == 1:\n",
        "                heads_in_round += 1\n",
        "        results.append(heads_in_round)\n",
        "    return results\n",
        "\n",
        "\n",
        "# Calculate statistics\n",
        "# Returns the sorted distribution of heads\n",
        "# as an array with num_heads and another with the corresponding  count\n",
        "def calculate_statistics(results, num_coins_per_round, index_num_repetitions):\n",
        "    print(\"\\n calculate_statistics\")\n",
        "    total_heads = sum(results)\n",
        "    num_repetitions = flipping_numbers_to_be_sampled[index_num_repetitions]\n",
        "    proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "    heads_distribution = Counter(results)\n",
        "\n",
        "    # Arrays to keep values\n",
        "    num_heads_values = []\n",
        "    count_values = []\n",
        "    relativeFreq_values = []\n",
        "\n",
        "    # Print the results\n",
        "    print(f\"Simulation of {num_repetitions} rounds \")\n",
        "    print(f\"with {num_coins_per_round} coins per round:\")\n",
        "    print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "    print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "    print(\"\\nDistribution of heads:\")\n",
        "    # Sort the distribution for better readability\n",
        "    sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "    for num_heads, count in sorted_distribution.items():\n",
        "        relative_frequency = count/num_repetitions\n",
        "        print(f\"{num_heads} heads: {count} times,   {relative_frequency} relative frequency\")\n",
        "        # z_heights[num_heads, index_num_repetitions] = relative_frequency\n",
        "        z_heights[index_num_repetitions, num_heads] = relative_frequency\n",
        "        print(f\"num_heads = {num_heads} index_num_repetitions = {index_num_repetitions}\")\n",
        "        print(f\"z_heights[{index_num_repetitions},{num_heads}] = {z_heights[index_num_repetitions, num_heads]}\")\n",
        "    print(f\"z_heights  {z_heights}\")\n",
        "    return z_heights\n",
        "\n",
        "\n",
        "# Find and plot the observed distribution of the number of heads\n",
        "# for various flip values for a fix number of coins.\n",
        "def plot_hyper_distribution(num_coins_per_round):\n",
        "    print(\"plot_hyper_distribution(num_coins_per_round):\")\n",
        "    print(f\"num_coins_per_round = {num_coins_per_round}\")\n",
        "    print(f\"flipping_numbers_to_be_sampled = {flipping_numbers_to_be_sampled}\")\n",
        "    print(f\"len(flipping_numbers_to_be_sampled) = {len(flipping_numbers_to_be_sampled)}\")\n",
        "\n",
        "for index_num_repetitions in range(len(flipping_numbers_to_be_sampled)):\n",
        "    print(\"\\n=============================\\n\")\n",
        "    print(f\"index_num_repetitions = {index_num_repetitions}\")\n",
        "    num_repetitions = flipping_numbers_to_be_sampled[index_num_repetitions]\n",
        "    print(f\"Flipping number =  {num_repetitions}\")\n",
        "    results = simulate_coin_flips(num_coins_per_round, num_repetitions)\n",
        "    z_heights = calculate_statistics(results, num_coins_per_round, index_num_repetitions)\n",
        "    #print(f\"z_heights =  {z_heights }\" )\n",
        "    index_num_repetitions += 1\n",
        "\n",
        "# Create a meshgrid for the x and y coordinates of the bars\n",
        "_xx, _yy = np.meshgrid(x_data, y_data)\n",
        "print(f\"_xx = {_xx} \\n\")\n",
        "print(f\"_yy = {_yy} \\n\")\n",
        "x_pos, y_pos = _xx.ravel(), _yy.ravel()\n",
        "print(f\"x_pos = {x_pos} \\n\")\n",
        "print(f\"y_pos = {y_pos} \\n\")\n",
        "z_pos = np.zeros_like(x_pos)  # All bars start at z=0\n",
        "print(f\"z_pos = {z_pos} \\n\")\n",
        "dz = z_heights.ravel() # Heights of the bars\n",
        "print(f\"dz = {dz} \\n\\n\")\n",
        "\n",
        "print(\"Is there a tendency of the sampled distributions\")\n",
        "print(\"when the number of repetitions increases?\")\n",
        "for i in range(4):\n",
        "    print(f\"Number of repetitions {flipping_numbers_to_be_sampled[i]}: sampled distribution{z_heights[i]}\")\n",
        "print(\"Mathematically expected distribution: [0.25, 0.5, 0.25]\")\n",
        "\n",
        "# Create the 3D plot\n",
        "fig = plt.figure()\n",
        "ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "# Plot the 3D bars\n",
        "ax.bar3d( y_pos, x_pos, z_pos, dx, dy, dz, shade=True)\n",
        "\n",
        "# Set labels and title\n",
        "ax.set_xlabel('num_repetitions = 10^x')\n",
        "ax.set_ylabel('num_heads')\n",
        "ax.set_zlabel('relativeFreq')\n",
        "ax.set_title('Tendency towards the Binomial Distribution')\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "def main():\n",
        "    plot_hyper_distribution(num_coins_per_round)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4wJ82aZEx9xy"
      },
      "source": [
        "> **Ejercicio.** Ejecute el programa anterior. ¿Existe una tendencia estable de las distribuciones muestreadas hacia un límite? ¿Coincide el límite con la distribución matemáticamente esperada?\n",
        "\n",
        ">> **Respuesta.** Se observa una tendencia estable hacia un límite, y este coincide con la distribución matemáticamente esperada.\n",
        "\n",
        "> **Ejercicio.** El programa anterior funciona perfectamente para el caso en el que lanzamos 2 monedas. Generalícelo para cubrir cualquier número de monedas.\n",
        ">>\n",
        ">> **Respuesta.** Probamos el código para varias monedas iguales a 6. Funcionó perfectamente, pero carecía de la distribución matemáticamente esperada. Por lo tanto, abrimos una celda de código en este documento. Colab nos invitó a solicitarle generar un código, así que hicimos clic en la palabra \"generar\" y solicitamos:\n",
        ">>> la distribución binomial general.\n",
        ">>\n",
        ">> En respuesta, Gemini presentó el siguiente código:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "iJKWKPLux9xz"
      },
      "outputs": [],
      "source": [
        "# Program tendencyToBinomialGraphGeneral.py\n",
        "# Code developed by Gemini inside Colab.\n",
        "# It reuses and improves our code,\n",
        "# specially in regard with the graphs.\n",
        "\n",
        "# Libraries and local rename\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np # Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "\n",
        "# Parameters for the simulation\n",
        "flipping_numbers_to_be_sampled = [10, 100, 1000, 10000]\n",
        "\n",
        "\n",
        "# Simulate coin flips\n",
        "# Returns an array with the number of heads per round\n",
        "def simulate_coin_flips(num_coins_per_round, num_repetitions):\n",
        "    results = []\n",
        "    for _ in range(num_repetitions):\n",
        "        heads_in_round = 0\n",
        "        for _ in range(num_coins_per_round):\n",
        "            # 0 for tails, 1 for heads\n",
        "            if random.choice([0, 1]) == 1:\n",
        "                heads_in_round += 1\n",
        "        results.append(heads_in_round)\n",
        "    return results\n",
        "\n",
        "\n",
        "# Calculate statistics\n",
        "# Returns the sorted distribution of heads\n",
        "# as an array with num_heads and another with the corresponding  relative frequency\n",
        "def calculate_statistics(results, num_coins_per_round, index_num_repetitions, num_repetitions, z_heights):\n",
        "    print(\"\\n calculate_statistics\")\n",
        "    total_heads = sum(results)\n",
        "    proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "    heads_distribution = Counter(results)\n",
        "\n",
        "    # Print the results\n",
        "    print(f\"Simulation of {num_repetitions} rounds \")\n",
        "    print(f\"with {num_coins_per_round} coins per round:\")\n",
        "    print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "    print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "    print(\"\\nDistribution of heads:\")\n",
        "    # Sort the distribution for better readability\n",
        "    sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "    for num_heads, count in sorted_distribution.items():\n",
        "        relative_frequency = count/num_repetitions\n",
        "        print(f\"{num_heads} heads: {count} times,   {relative_frequency} relative frequency\")\n",
        "        if num_heads <= num_coins_per_round and index_num_repetitions < len(flipping_numbers_to_be_sampled):\n",
        "            z_heights[index_num_repetitions, num_heads] = relative_frequency\n",
        "            print(f\"z_heights[{index_num_repetitions},{num_heads}] = {z_heights[index_num_repetitions, num_heads]}\")\n",
        "\n",
        "    print(f\"z_heights  {z_heights}\")\n",
        "    return z_heights\n",
        "\n",
        "\n",
        "# Find and plot the observed distribution of the number of heads\n",
        "# for various flip values for a fix number of coins.\n",
        "def plot_hyper_distribution(num_coins_per_round):\n",
        "    print(\"plot_hyper_distribution(num_coins_per_round):\")\n",
        "    print(f\"num_coins_per_round = {num_coins_per_round}\")\n",
        "    print(f\"flipping_numbers_to_be_sampled = {flipping_numbers_to_be_sampled}\")\n",
        "    numb_flipping_values = len(flipping_numbers_to_be_sampled)\n",
        "    print(f\"len(flipping_numbers_to_be_sampled) = {numb_flipping_values}\")\n",
        "\n",
        "    # Data for the graph\n",
        "    x_data = np.arange(num_coins_per_round + 1)\n",
        "    print(f\"x_data = {x_data} \\n\")\n",
        "    y_data =  np.arange(numb_flipping_values)\n",
        "    print(f\"y_data = {y_data} \\n\")\n",
        "\n",
        "    # Create a meshgrid for the x and y coordinates of the bars\n",
        "    _xx, _yy = np.meshgrid(x_data, y_data)\n",
        "    print(f\"_xx = {_xx} \\n\")\n",
        "    print(f\"_yy = {_yy} \\n\")\n",
        "    x_pos, y_pos = _xx.ravel(), _yy.ravel()\n",
        "    print(f\"x_pos = {x_pos} \\n\")\n",
        "    print(f\"y_pos = {y_pos} \\n\")\n",
        "    z_pos = np.zeros_like(x_pos)  # All bars start at z=0\n",
        "\n",
        "    z_heights = 1.0 * np.zeros((numb_flipping_values, num_coins_per_round + 1)) # z_heights initialization\n",
        "    print(f\"z_heights initialized = {z_heights} \\n\")\n",
        "\n",
        "\n",
        "    for index_num_repetitions in range(numb_flipping_values):\n",
        "        print(\"\\n=============================\\n\")\n",
        "        print(f\"index_num_repetitions = {index_num_repetitions}\")\n",
        "        num_repetitions = flipping_numbers_to_be_sampled[index_num_repetitions]\n",
        "        print(f\"Flipping number =  {num_repetitions}\")\n",
        "        results = simulate_coin_flips(num_coins_per_round, num_repetitions)\n",
        "        z_heights = calculate_statistics(results, num_coins_per_round, index_num_repetitions, num_repetitions, z_heights)\n",
        "\n",
        "\n",
        "    dz = z_heights.ravel() # Heights of the bars\n",
        "    print(f\"dz = {dz} \\n\\n\")\n",
        "\n",
        "    print(\"Is there a tendency of the sampled distributions\")\n",
        "    print(\"when the number of repetitions increases?\")\n",
        "    for i in range(numb_flipping_values):\n",
        "        print(f\"Number of repetitions {flipping_numbers_to_be_sampled[i]}: sampled distribution{z_heights[i]}\")\n",
        "\n",
        "    # Create the 3D plot\n",
        "    fig = plt.figure(figsize=(10, 8))\n",
        "    ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "    # Define the dimensions of the bars\n",
        "    dx = dy = 0.6  # Width and depth of the bars\n",
        "\n",
        "    # Plot the 3D bars\n",
        "    ax.bar3d( y_pos, x_pos, z_pos, dx, dy, dz, shade=True)\n",
        "\n",
        "    # Set labels and title\n",
        "    ax.set_xlabel('Number of Repetitions (10^x)')\n",
        "    ax.set_ylabel('Number of heads')\n",
        "    ax.set_zlabel('Relative Frequency')\n",
        "    ax.set_title('Tendency towards the Binomial Distribution')\n",
        "\n",
        "    # Set the tick labels for the y-axis (number of repetitions)\n",
        "    ax.set_yticklabels([f'10^{i+1}' for i in range(numb_flipping_values)])\n",
        "\n",
        "    # Display the plot\n",
        "    plt.show()\n",
        "\n",
        "\n",
        "# Example usage:\n",
        "# plot_hyper_distribution(num_coins_per_round=5)\n",
        "# plot_hyper_distribution(num_coins_per_round=10)\n",
        "plot_hyper_distribution(num_coins_per_round=20) # Example with 20 coins per round"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6nrwcQIfx9xz"
      },
      "source": [
        "> **Ejercicio.** Ejecuta el código de Gemini y evalúalo.\n",
        "\n",
        ">> **Respuesta.** El código funciona espectacularmente bien para 20 monedas, aunque el número de caras en el gráfico está incorrectamente numerado. Este código mejora el del autor.\n",
        "\n",
        "\n",
        "Disponemos de datos observacionales, pero carecemos de la distribución matemáticamente esperada. Este vacío nos impide relacionar la teoría con la observación. Debemos llenar este vacío para lograr algo con un toque científico.\n",
        "\n",
        "# LA DISTRIBUCIÓN BINOMIAL ESPERADA\n",
        "\n",
        "La Ciencia compara lo que se observa con lo que se piensa. En este caso, la observación corresponde al resultado de nuestras simulaciones, mientras que lo que se piensa se deriva de modelos matemáticos.\n",
        "\n",
        "Mostremos ahora la idea principal del modelo matemático que predice la forma de la Distribución Binomial para todos los valores posibles de $n$, el número de monedas. Seguimos un método de inducción, comenzando con la observación simple e infiriendo lo que podría ser más general.\n",
        "\n",
        "Para continuar, necesitamos dos reglas importantes de la teoría de la probabilidad.\n",
        "\n",
        "- La primera regla es:\n",
        ">\n",
        "> *Para eventos independientes, $A$ y $B$, la probabilidad de   su intersección $p(A \\cap B)$, es el producto de probabilidades*:\n",
        ">>\n",
        ">> $p(A \\cap B) = p(A)p(B)$\n",
        ">>\n",
        ">\n",
        "> **Ejemplo.** Si la probabilidad de cara es 1/2 y la de cruz es 1/2, ¿cuál es la probabilidad de obtener dos caras al lanzar dos monedas? Dado que asumimos que ningún evento influye en otro, la probabilidad de cara en la primera moneda y cara en la segunda es (1/2) x (1/2) = 1/4. Esto significa una opción entre cuatro cuando todas son equiprobables. De hecho, denotando cara como h, y sello o cruz como t, para dos monedas obtenemos hh, ht, th, tt, y las cuatro opciones tienen la misma probabilidad debido a la independencia y la equiprobabilidad de h y t. Por lo tanto, la probabilidad de cada una es 1/4.\n",
        ">\n",
        "> Esta regla de multiplicación de probabilidades para eventos independientes es demasiado abstracta para ser aceptada por todos. Derivémosla desde una perspectiva más sencilla.\n",
        ">\n",
        "> Definamos que el evento $A$ es independiente del evento $B$ cuando $B$ no influye en $A$. Más específicamente, cuando la probabilidad de $A$ dado $B$ es igual a la probabilidad de $A$. Pero, ¿cómo definiremos la probabilidad de $A$ dado $B$? No consideramos la relación causa-efecto, sino solo los procedimientos de conteo. En este sentido, $B$ influye en $A$ si tienen algo en común, y la influencia es mayor cuanto mayor sea la intersección con respecto a $B$. Por eso definimos la probabilidad de $A$ dado $B$, denotada $P(A/B)$, como\n",
        ">>\n",
        ">> $P(A/B) = \\frac{p(A \\cap B )}{p(B)}$\n",
        ">>\n",
        "> donde $A \\cap B $ es la intersección, es decir, el conjunto de todos los eventos comunes. Por lo tanto, el evento $A$ es independiente del evento $B$ cuando\n",
        ">>\n",
        ">> $P(A/B) = \\frac{p(A \\cap B )}{p(B)} = P(A)$\n",
        ">>\n",
        "> Por consiguiente, el evento $A$ es independiente del evento $B$ cuando\n",
        ">>\n",
        ">> $ p(A \\cap B ) = P(A)p(B) $\n",
        ">>\n",
        "> De la misma manera, el evento $B$ es independiente del evento $A$ cuando\n",
        ">>\n",
        ">> $ p(B \\cap A ) = P(B)p(A) $\n",
        ">>\n",
        "> Decimos que **los eventos $A$ y $B$ son independientes** cuando ninguno depende del otro. Es decir, cuando\n",
        ">>\n",
        ">> $ p(A \\cap B ) = p(A)p(B) $\n",
        ">>\n",
        "\n",
        "- La segunda regla es:\n",
        ">\n",
        "> *Cuando dos sucesos $A$ y $B$ son disjuntos, la probabilidad de su unión, $p(A \\cup B)$, es la suma de probabilidades,* es decir,\n",
        ">>\n",
        ">> $p(A \\cup B) = p(A) + p(B)$\n",
        ">>\n",
        ">> donde la unión lista todos los eventos de $A$ y añade los de $B$ que aparezcan por primera vez. Por lo tanto, si $A$ y $B$ no tienen nada en común, la probabilidad de su unión cuenta todos los números de ambos conjuntos sin ninguna resta porque no hay doble conteo.\n",
        ">\n",
        "> **Ejemplo:** Si lanzamos dos monedas, ¿cuál es la probabilidad de obtener una cara? Para obtener una cara, debemos obtener ht o th. Más explícitamente, la primera moneda podría ser h y la segunda t, con probabilidad $1/4$, o la primera podría ser t y la otra h, con probabilidad $1/4$. Estas dos opciones no tienen nada en común. Son disjuntas. Por lo tanto, la probabilidad de obtener una cara es la suma de estas dos probabilidades: $1/4 + 1/4 = 1/2$,lo que significa que la mitad de los eventos contendrán una cara. Esto es correcto: todos los eventos son tt, ht, th, tt y la mitad de ellos tienen una cara.\n",
        "\n",
        "Aplicaremos estas reglas en todas las etapas siguientes. La primera regla es la de la multiplicación de probabilidades para sucesos independientes, y la segunda es la de la suma de probabilidades para sucesos disjuntos.\n",
        "\n",
        "¿Cómo procederemos cuando dos sucesos no son disjuntos?\n",
        "\n",
        "> **Ejercicio.** Si lanzamos dos monedas, ¿cuál es la probabilidad de obtener exactamente una cara o una cruz?\n",
        ">>\n",
        ">> **Respuesta.** Si lanzamos dos monedas, puede obtenerse exactamente una cara si obtenemos ht o th, y puede obtenerse exactamente una cruz en la misma situación. Por lo tanto, la probabilidad de obtener exactamente una cara o una cruz es de 1/2.\n",
        "\n",
        "Con estas dos reglas, podemos hacer predicciones adecuadas.\n",
        "\n",
        "Trabajamos con una moneda generalizada cuya probabilidad de cara es $p$ y la de cruz es $q = 1-p$. Cara se denota h y cruz t. La probabilidad de t más la de h es $q + p = p + q = 1$. La tarea consiste en predecir la forma de la Distribución de caras, es decir, la probabilidad esperada de obtener $k$ caras al lanzar $n$ monedas. Por lo tanto, tenemos una función que asigna una probabilidad a cada $k$ entre $0$ y $n$. Esta función recibe un nombre: es una **variable aleatoria** y se denota $X$. En resumen, $X$ cuenta el número de caras y asigna una probabilidad.\n",
        "\n",
        "Hagamos algunas predicciones concretas sobre la forma de la Distribución Binomial.\n",
        "\n",
        "> **Ejemplo.** Si lanzamos una moneda, podemos obtener t o h. En caso de obtener t, $X$ es $0$ con probabilidad $q$. Si obtenemos h, $X$ es $1$ con probabilidad $p$. Por lo tanto, la variable aleatoria $X$, que cuenta caras, es la función definida por:\n",
        "\n",
        ">>\n",
        ">> $t \\rightarrow X = 0 \\rightarrow q$\n",
        ">>\n",
        ">> $h \\rightarrow X = 1 \\rightarrow p$\n",
        ">>\n",
        ">> Todas las probabilidades deben sumar $1$. ¿Se cumple? Sí:\n",
        ">>\n",
        ">> $p + q = p + (1-p) = p +1 -p = 1$\n",
        "\n",
        "Ejemplo. Si lanzamos dos monedas, el resultado podría ser tt, th, ht, hh. Los valores correspondientes de $X$ son $0$, $1$, $1$, $2$, con las probabilidades correspondientes $qq = q^2$, $qp$, $pq$, $pp = p^2$. Por lo tanto, la variable aleatoria $X$, que cuenta las caras, es la función definida por\n",
        ">>\n",
        ">> $tt \\rightarrow X = 0 \\rightarrow q^2$        \n",
        ">> $th, ht \\rightarrow X = 1 \\rightarrow 2qp = 2 pq$         \n",
        ">> $hh \\rightarrow X = 2 \\rightarrow p^2$       \n",
        ">>  \n",
        ">> Todas las probabilidades deben sumar $1$. ¿Se cumple? Sí:    \n",
        ">> $S = q^2 + 2pq + p^2 = (p + q)^2 = 1^2 = 1 $\n",
        "\n",
        "\n",
        "> **Inferencia.** La forma de la Distribución Binomial para $n = 1$ y $n = 2$ monedas viene dada por $(q+p)^n$. Nuestra inferencia es que esto es válido para cualquier número de monedas $n$.\n",
        "\n",
        "> **Ejemplo.** ¿Es cierta nuestra inferencia para $n=3$? Sí, lo es. Para comprobarlo, necesitamos enumerar todas las opciones, pero sin repeticiones. Para ello, recurramos a los números binarios, o números en base $2$. En esa notación, $0$ significa $0$ caras o t, y $1$ significa $1$ cara o h:\n",
        ">>\n",
        ">> $0 \\rightarrow 000 \\rightarrow ttt  \\rightarrow X = 0 \\rightarrow q^3$   \n",
        ">> $1 \\rightarrow 001 \\rightarrow tth  \\rightarrow X = 1 \\rightarrow q^2 p$    \n",
        ">> $2 \\rightarrow 010 \\rightarrow tht  \\rightarrow X = 1 \\rightarrow q^2 p$    \n",
        ">> $3 \\rightarrow 011 \\rightarrow thh  \\rightarrow X = 2 \\rightarrow q p^2$    \n",
        ">> $4 \\rightarrow 100 \\rightarrow htt  \\rightarrow X = 1 \\rightarrow q^2 p$    \n",
        ">> $5 \\rightarrow 101 \\rightarrow hth  \\rightarrow X = 2 \\rightarrow q p^2$    \n",
        ">> $6 \\rightarrow 110 \\rightarrow hht  \\rightarrow X = 2 \\rightarrow q p^2$    \n",
        ">> $7 \\rightarrow 111 \\rightarrow hhh  \\rightarrow X = 3 \\rightarrow p^3$    \n",
        ">\n",
        "> Test: Todas las probabilidades deben sumar $1$. ¿Se cumple? Veammos:\n",
        ">>\n",
        ">> $S = q^3  + q^2 p + q^2 p + q p^2 + q^2 p + q p^2 + q p^2 + p 3$\n",
        ">>\n",
        "> Reordenando para poner juntos a los términos semejantes, obtenemos\n",
        ">>\n",
        ">> $ S = q^3  + q^2 p + q^2 p + q^2 p + q p^2 + q p^2 + q p^2 + p 3$\n",
        ">\n",
        "> Asociando:\n",
        ">>\n",
        ">> $ S = q^3  + 3q^2 p  + 3q p^2 + p 3 = (q + p)^3 = (p+q)^3 = 1 ^3 = 1$\n",
        ">\n",
        "> Hemos pasado el test.\n",
        "\n",
        "\n",
        "\n",
        "> *Predicción 1.* La forma de la distribución binomial para $n = 3$ está definida por la variable aleatoria $X$, dada por:\n",
        ">>\n",
        ">> $0 \\rightarrow 1q^3 $      \n",
        ">> $1 \\rightarrow 3q^2p$      \n",
        ">> $2 \\rightarrow 3q p^2$      \n",
        ">> $3 \\rightarrow 1p^3 $      \n",
        ">\n",
        "> *Predicción 2.* Si $p = q = 1/2$, la campana correspondiente es simétrica y las probabilidades son:\n",
        ">>\n",
        ">> $0 \\rightarrow q^3 = 1 (1/2)^3 = 1/8$      \n",
        ">> $1 \\rightarrow 3q^2p = 3 (1/2)^2 (1/2) = 3/8$      \n",
        ">> $2 \\rightarrow 3q p^2 3 (1/2) (1/2)^2 = $3/8     \n",
        ">> $3 \\rightarrow 1p^3 = (1/2)^3 = 1/8$      \n",
        ">>\n",
        ">> Por lo tanto, las alturas de las barras tienen una relación 1:3:3:1.\n",
        "\n",
        "La generalidad de estos procedimientos de conteo se denomina ***combinatoria***.\n",
        "\n",
        "**Ejercicio.** Use el truco de los números binarios para predecir la forma de la distribución binomial para $n = 4$. El desarrollo binomial para $= 4$ es:\n",
        ">>\n",
        ">>$(q + p)^4 = q^4 + 4 q^3 p + 6 q^2 p^2 + 4 qp^3 + p^4$\n",
        "\n",
        "> **Respuesta.** Todos los casos con $n = 4$ son:\n",
        "\n",
        "\n",
        ">> $0 \\rightarrow 0000 \\rightarrow tttt  \\rightarrow X = 0 \\rightarrow q^4$    \n",
        ">> $1 \\rightarrow 0001 \\rightarrow ttth  \\rightarrow X = 1 \\rightarrow q^3p$    \n",
        ">> $2\\rightarrow 0010  \\rightarrow ttht  \\rightarrow X = 1  \\rightarrow q^3p $    \n",
        ">> $3 \\rightarrow 0011  \\rightarrow tthh  \\rightarrow X = 2  \\rightarrow q^2 p^2 $    \n",
        ">> $4 \\rightarrow 0100 \\rightarrow thtt  \\rightarrow X =  1 \\rightarrow  q^3 p$    \n",
        ">> $5 \\rightarrow  0101 \\rightarrow thth  \\rightarrow X =  2 \\rightarrow   q^2   p^2$     \n",
        ">> $6 \\rightarrow 0110 \\rightarrow  thht \\rightarrow X = 2  \\rightarrow   q^2   p^2$       \n",
        ">> $7  \\rightarrow 0111 \\rightarrow thhh  \\rightarrow X = 3  \\rightarrow   q p^3$        \n",
        ">> $8  \\rightarrow 1000 \\rightarrow httt \\rightarrow X =  1 \\rightarrow   q^3 p$        \n",
        ">> $9 \\rightarrow 1001 \\rightarrow  htth \\rightarrow X = 2  \\rightarrow   q^2 p^2$    \n",
        ">> $10 \\rightarrow 1010 \\rightarrow htht  \\rightarrow X =  2 \\rightarrow   q^2 p^2$    \n",
        ">> $11 \\rightarrow 1011 \\rightarrow  hthh \\rightarrow X = 3  \\rightarrow   q p^3$    \n",
        ">> $12 \\rightarrow 1100 \\rightarrow hhtt  \\rightarrow X =  2 \\rightarrow   q^2 p^2$    \n",
        ">> $13 \\rightarrow 1101 \\rightarrow hhth  \\rightarrow X =   3\\rightarrow  q p^3 $    \n",
        ">> $14 \\rightarrow 1110 \\rightarrow hhht  \\rightarrow X =  3 \\rightarrow  q p^3 $    \n",
        ">> $15 \\rightarrow  1111 \\rightarrow hhhh  \\rightarrow X =  4 \\rightarrow   p^4 $    \n",
        ">\n",
        "> Test: todas las probabilidades deben sumar 1. ¿Es verdad? Veamos:  \n",
        ">>\n",
        ">> $S = q^4   + q^3 p +  q^3 p +  q^2 p^2 +  q^3 p +  q^2 p^2 +  q^2 p^2 +  q p^3 +  q^3 p +  q^2 p^2 +  q^2 p^2 +  q p^3 +  q^2 p^2 +  q p^3 +  q p^3 +   p^4 $\n",
        ">\n",
        "> Reordenando para poner juntos los términos semejantes, obtenemos:\n",
        ">>\n",
        ">>$S = q^4   + ( q^3 p +  q^3 p +  q^3 p +   q^3 p ) + (q^2 p^2 +  q^2 p^2 +  q^2 p^2   + q^2 p^2 +  q^2 p^2 +  q^2 p^2 ) +  (q p^3 +  q p^3 +  q p^3 +    qp^3 ) + p^4 $\n",
        ">\n",
        "> Asociando:\n",
        ">>\n",
        ">> $ S = q^4  + 4q^3 p  + 6q^2 p^2 +  4 q  p^3 +  p 4 = (q + p)^4 = (p+q)^4 = 1 ^4 = 1$\n",
        "> tal como se exigía.\n",
        "\n",
        "> *Predicción 1.* La silueta de la Distribución Binomial está dada por la variable aleatoria $X$, definida por:  \n",
        ">\n",
        ">> $0 \\rightarrow 1q^4 $    \n",
        ">> $1 \\rightarrow 4q^3p$    \n",
        ">> $2 \\rightarrow 6q^2 p^2 $    \n",
        ">> $3 \\rightarrow 4qp^3 $    \n",
        ">> $3 \\rightarrow 1p^4 $    \n",
        ">\n",
        "> Predicción 2: Si $p = q = 1/2$, la campana correspondiente es simétrica y sus probabilidades son:  \n",
        ">>\n",
        ">> $0 \\rightarrow 1 (1/2)^4  = 1/16$    \n",
        ">> $1 \\rightarrow 4q^3p = 4 (1/2)^3 (1/2) = 4 (1/2)^4 = 4/16$    \n",
        ">> $2 \\rightarrow 6q^2 p^2 = 6 (1/2)^2 (1/2)^2 = 6 (1/2)^4 = 6/16 $    \n",
        ">> $3 \\rightarrow 4 q p^3  =4 (1/2) (1/2)^3 = 4  (1/2)^4 = 4/16$    \n",
        ">> $4 \\rightarrow 1p^4 =  (1/2)^4  = 1/16$    \n",
        ">\n",
        "> Por tanto, las alturas de las barras están en relación 1:4:6:4:1\n",
        "\n",
        "¿Qué viene después? Necesitamos generalizar.\n",
        "\n",
        "Necesitamos una fórmula general para la expanción de  $(a+b)^n$, juntamente con su prueba.\n",
        "\n",
        "La fórmula general es:\n",
        ">\n",
        "> $(q + p)^n=\\sum_{k=0}^{n}{n!\\over{(n-k)!k!}}q^kp^{n-k}$\n",
        "\n",
        "donde el factorial   $n!$ está definido recursivamente por:\n",
        ">\n",
        "> $0! = 1 $ and $n! = (n-1)! n$,\n",
        "\n",
        "> **Ejemplo.**  $5! = 4! \\times 5 = 3! \\times 4  \\times 5  = 2! \\times 3   \\times 4 \\times 5 = 1! \\times 2 \\times 3   \\times 4 \\times 5  = 0! \\times 1 \\times 2 \\times 3   \\times 4 \\times 5  = 1 \\times 1 \\times 2 \\times 3   \\times 4 \\times 5  =  120$.\n",
        "\n",
        "> **Ejercicio.** Calcule $7!$.\n",
        "\n",
        "> **Respuesta.** $7! = 6! \\times 7 = 5! \\times 6 \\times 7 = 120 \\times 6 \\times 7 \\sim 5000 $\n",
        "\n",
        "Mostremos que la fórmula binomial reproduce lo que ya sabemos:\n",
        "\n",
        "> **Ejemplo.** Probemos que la fórmula es correcta para  $n=1$. Debemos probar que\n",
        ">\n",
        ">> $(q + p)^n=\\sum_{k=0}^{n}{n!\\over{(n-k)!k!}}q^kp^{n-k}$\n",
        "se reduce para $n = 1$ a\n",
        ">>\n",
        ">> $ (p+q)^1 = p+q$.\n",
        ">\n",
        "> Esto se logra reemplazando los factoriales:  \n",
        ">>\n",
        ">> $(q + p)^1=\\sum_{k=0}^{1}{1!\\over{(1-k)!k!}}q^kp^{1-k}$\n",
        ">\n",
        "> Esto es una suma con dos términos, el primero con   $k= 0$ y el segundo con $k = 1$:\n",
        ">>\n",
        ">>$(q + p)^1 = {1!\\over{(1-0)!0!}}q^0p^{1-0} + {1!\\over{(1-1)!1!}}q^1p^{1-1} = $   \n",
        ">> $ = {1\\over{1}} p^{1} + {1\\over{1}}q^1p^{0} $   \n",
        ">> $ =   p  +  q $   \n",
        "\n",
        "Hemos probado así que la fórmula es correcta para  $n = 1$.\n",
        "\n",
        "\n",
        ">> **Ejemplo.**. Verifiquemos que la Expansión Binomial es correcta para  $n = 2$.\n",
        "\n",
        "> La fórmula para $n = 2 $ dice\n",
        ">>\n",
        ">> $(q + p)^2=\\sum_{k=0}^{2}{2!\\over{(2-k)!k!}}q^kp^{2-k}$\n",
        ">>\n",
        "> y tiene 3 términos, para  $k = 0, 1, 2$:\n",
        ">>\n",
        ">> $(q + p)^2= {2!\\over{(2-0)!0!}}q^0p^{2-0}$    \n",
        ">> $ + {2!\\over{(2-1)!1!}}q^1p^{2-1}$   \n",
        ">> $+ {2!\\over{(2-2)!2!}}q^2p^{2-2}$   \n",
        ">> $= {2\\over{2}}p^2$   \n",
        ">> $ + {2\\over{1}}q p$   \n",
        ">> $+ {2\\over{2}}q^2$   \n",
        ">> $= p^2 + 2pq + q^2 $, tal como se halló antes.\n",
        "\n",
        "\n",
        "> **Ejercicio.** Verifique que la fórmula es correcta para  $n = 3$.\n",
        ">> **Respuesta.** Tenemos 4 términos para $k = 0,1,2,3$:    \n",
        ">>    \n",
        ">> $(q + p)^3=\\sum_{k=0}^{3}{3!\\over{(3-k)!k!}}q^kp^{3-k} $   \n",
        ">> $ = {3!\\over{(3-0)!0!}}q^0p^{3-0}  + {3!\\over{(3-1)!1!}}q^1p^{3-1} + {3!\\over{(3-2)!2!}}q^2p^{3-2} + {3!\\over{(3-3)!3!}}q^3p^{3-3}  $   \n",
        ">> $ = {3!\\over{(3)!0!}}q^0p^{3} + {3!\\over{(2)! }}q p^{2} + {3!\\over{1!2!}}q^2p + {3!\\over{0!3!}}q^3p^0 $   \n",
        ">> $ = {6\\over{6 }} p^{3} + {6\\over{2 }}q p^{2} +{6\\over{2}}q^2p +\n",
        "{6\\over{6}}q^3   $   \n",
        ">> $ =  p^{3} + 3q p^{2} +3q^2p +  q^3   $   \n",
        "\n",
        "\n",
        "La demostración general del Desarrollo Binomial o Binomio de Newton afirma que la fórmula es válida para cada $n$ de 1 a $\\infty$. Esto se realiza aplicando el **Principio Matemático de Inducción**, que establece que para ascender en una escalera infinita, basta con cumplir dos condiciones:\n",
        "- Se puede alcanzar el primer escalón,\n",
        "- Siempre se puede ascender al escalón $n+1$, si se está en el escalón $n$.\n",
        "\n",
        "Por lo tanto, para demostrar el Teorema del Binomio, necesitamos demostrarlo para el primer término, algo que ya hicimos redundantemente para $n= 1, 2, 3 $. En segundo lugar, debemos demostrar que podemos pasar de cualquier escalón al siguiente.\n",
        "\n",
        "> **Investigación.** Supongamos que estamos en el escalón $n$, es decir, que la fórmula de desarrollo es válida para la potencia $n$. A partir de esto, se debe demostrar que se puede ascender al siguiente escalón, es decir, que el desarrollo binomial es válido para $n+1$. En otras palabras, debemos asumir que\n",
        ">\n",
        ">> $(q + p)^n=\\sum_{k=0}^{n}{n!\\over{(n-k)!k!}}q^kp^{n-k}$\n",
        ">\n",
        "> Ahora, demos multiplicar a ambos lados de esta ecuación por   $(q+p)$\n",
        ">>\n",
        ">> $(q+p) (q + p)^n=(q+p) \\sum_{k=0}^{n}{n!\\over{(n-k)!k!}}q^kp^{n-k}$\n",
        ">\n",
        "> y debemos mostrar que:\n",
        ">>\n",
        ">> $(q + p)^{n+1}=\\sum_{k=0}^{n+1}{(n+1)!\\over{(n+1-k)!k!}}q^kp^{n+1-k}$\n",
        ">\n",
        "> Esto se puede encontrar en:\n",
        ">\n",
        "> https://www.lifeder.com/teorema-binomio/\n",
        ">\n",
        "> juntamente con  \n",
        ">\n",
        "> https://esfm.egormaximenko.com/algebra/binomial_theorem_es.pdf\n",
        ">\n",
        "> y un hermoso prerequisito, el Triángulo de Pascal:\n",
        ">\n",
        "> https://es.wikipedia.org/wiki/Regla_de_Pascal\n",
        ">\n",
        "> También necesitamos la relación general de estos procedimientos algebraicos con la probabilidad, más exactamente con la combinatoria:\n",
        ">\n",
        "> https://www.cimat.mx/~jortega/MaterialDidactico/EPyE09/Cap2.pdf\n",
        "\n",
        "Con todo esto, ahora podemos afirmar en qué creemos:\n",
        "\n",
        "Supongamos un experimento con $n$ monedas, cuya probabilidad de cara es $p$ y la de cara es $q$, en el que contamos el número de caras. Repetimos el experimento una y otra vez para obtener una estimación de la Distribución Binomial, que predice la frecuencia relativa de $k$ caras. Entonces, la frecuencia relativa de $k$ caras observada en el experimento tiende a la probabilidad predicha por la Expansión Binomial: ${n!\\over{(n-k)!k!}}p^kq^{n-k}$.\n",
        "\n",
        "Si tenemos una creencia, ¿Cuál es el paso siguiente en ciencia? ¡Ponerla a prueba!\n",
        "\n",
        "# PONIENDO NUESTRAS CREENCIAS A PRUEBA\n",
        "\n",
        "Debemos realizar nuestras simulaciones, elegir $n$ y, para cada $k \\le n$, calcular la frecuencia relativa de $k$ caras y comparar esas frecuencias con los valores predichos por nuestra creencia.\n",
        "\n",
        "Nuestro primer paso es ver qué tiene Python sobre la fórmula Binomial.\n",
        "\n",
        "\n",
        "\n",
        "> **Ejemplo.** Solicitamos a Colab:\n",
        ">\n",
        "> Código para el desarrollo binomial (p+q)^n\n",
        ">\n",
        "> Nos respondió con el siguiente código:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eEPfE203x9x0"
      },
      "outputs": [],
      "source": [
        "# Program binomialExpansionByGemini.py\n",
        "\n",
        "import math\n",
        "\n",
        "def binomial_expansion(p, q, n):\n",
        "    \"\"\"\n",
        "    Calculates the terms of the binomial expansion (p+q)^n.\n",
        "\n",
        "    Args:\n",
        "        p: The probability of the first outcome.\n",
        "        q: The probability of the second outcome (q = 1 - p).\n",
        "        n: The number of trials.\n",
        "\n",
        "    Returns:\n",
        "        A dictionary where keys are the number of successes (k)\n",
        "        and values are the corresponding probabilities.\n",
        "    \"\"\"\n",
        "    if not math.isclose(p + q, 1.0):\n",
        "        print(\"Warning: p + q should be equal to 1.\")\n",
        "\n",
        "    expansion_terms = {}\n",
        "    for k in range(n + 1):\n",
        "        # Calculate the binomial coefficient (n choose k)\n",
        "        binomial_coeff = math.comb(n, k)\n",
        "\n",
        "        # Calculate the probability of k successes\n",
        "        probability_k = binomial_coeff * (p ** k) * (q ** (n - k))\n",
        "\n",
        "        expansion_terms[k] = probability_k\n",
        "    return expansion_terms\n",
        "\n",
        "# Example usage for a fair coin (p=0.5, q=0.5) with 10 flips (n=10)\n",
        "p = 0.5\n",
        "q = 0.5\n",
        "n = 10\n",
        "binomial_probs = binomial_expansion(p, q, n)\n",
        "print(f\"Binomial expansion for (0.5 + 0.5)^{n}:\")\n",
        "for k, prob in binomial_probs.items():\n",
        "    print(f\"  {k} heads: {prob:.4f}\")\n",
        "\n",
        "# Example usage for a biased coin (p=2/3, q=1/3) with 10 flips (n=10)\n",
        "p = 2/3\n",
        "q = 1/3\n",
        "n = 10\n",
        "binomial_probs_biased = binomial_expansion(p, q, n)\n",
        "print(f\"\\nBinomial expansion for (2/3 + 1/3)^{n}:\")\n",
        "for k, prob in binomial_probs_biased.items():\n",
        "    print(f\"  {k} heads: {prob:.4f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n3gCWTw6x9x0"
      },
      "source": [
        "> **Ejercicio.** Ejecuta el código y evalúalo.\n",
        "\n",
        ">> **Respuesta.** El programa muestra dos casos. Grosso modo, parecen correctos. Pero, para evaluarlo mejor, usamos el código para calcular (0.5 + 0.5)². La respuesta fue: 0.25, 0.5, 0.25, lo cual fue correcto. Por lo tanto, retroalimentamos a Colab con un buen punto.\n",
        "\n",
        "> **Ejercicio.** Agrega al programa `tendencyToBinomialGraphGeneral.py`, desarrollado por Gemini, el código para la Expansión Binomial para contrastar la última distribución simulada con el límite matemáticamente esperado.\n",
        "\n",
        ">> **Respuesta.** El siguiente código muestra la tendencia de las distribuciones observadas del número de caras para n monedas a medida que aumenta el número de repeticiones y contrasta su límite con la distribución matemáticamente esperada. Las expectativas se cumplen con creces."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DR_SSzegx9x0"
      },
      "outputs": [],
      "source": [
        "# Program tendencyToBinomialGraphGeneral2.py\n",
        "# This program shows the tendency of\n",
        "# the sampled distribution of the number of heads\n",
        "# and compares its limit with\n",
        "# the mathematically expected distribution\n",
        "\n",
        "# Libraries and local rename\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np # Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "from mpl_toolkits.mplot3d import Axes3D\n",
        "\n",
        "# Parameters for the simulation\n",
        "flipping_numbers_to_be_sampled = [10, 100, 1000, 10000]\n",
        "num_coins_per_round  = 20\n",
        "\n",
        "# Simulate coin flips\n",
        "# Returns an array with the number of heads per round\n",
        "def simulate_coin_flips(num_coins_per_round, num_repetitions):\n",
        "    results = []\n",
        "    for _ in range(num_repetitions):\n",
        "        heads_in_round = 0\n",
        "        for _ in range(num_coins_per_round):\n",
        "            # 0 for tails, 1 for heads\n",
        "            if random.choice([0, 1]) == 1:\n",
        "                heads_in_round += 1\n",
        "        results.append(heads_in_round)\n",
        "    return results\n",
        "\n",
        "\n",
        "# Calculate statistics\n",
        "# Returns the sorted distribution of heads\n",
        "# as an array with num_heads and another with the corresponding  relative frequency\n",
        "def calculate_statistics(results, num_coins_per_round, index_num_repetitions, num_repetitions, z_heights):\n",
        "    print(\"\\n calculate_statistics\")\n",
        "    total_heads = sum(results)\n",
        "    proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "    heads_distribution = Counter(results)\n",
        "\n",
        "    # Print the results\n",
        "    print(f\"Simulation of {num_repetitions} rounds \")\n",
        "    print(f\"with {num_coins_per_round} coins per round:\")\n",
        "    print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "    print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "    print(\"\\nDistribution of heads:\")\n",
        "    # Sort the distribution for better readability\n",
        "    sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "    for num_heads, count in sorted_distribution.items():\n",
        "        relative_frequency = count/num_repetitions\n",
        "        print(f\"{num_heads} heads: {count} times,   {relative_frequency} relative frequency\")\n",
        "        if num_heads <= num_coins_per_round and index_num_repetitions < len(flipping_numbers_to_be_sampled):\n",
        "            z_heights[index_num_repetitions, num_heads] = relative_frequency\n",
        "            print(f\"z_heights[{index_num_repetitions},{num_heads}] = {z_heights[index_num_repetitions, num_heads]}\")\n",
        "\n",
        "    print(f\"z_heights  {z_heights}\")\n",
        "    return z_heights\n",
        "\n",
        "\n",
        "# Find and plot the observed distribution of the number of heads\n",
        "# for various flip values for a fix number of coins.\n",
        "def plot_hyper_distribution(num_coins_per_round):\n",
        "    print(\"plot_hyper_distribution(num_coins_per_round):\")\n",
        "    print(f\"num_coins_per_round = {num_coins_per_round}\")\n",
        "    print(f\"flipping_numbers_to_be_sampled = {flipping_numbers_to_be_sampled}\")\n",
        "    numb_flipping_values = len(flipping_numbers_to_be_sampled)\n",
        "    print(f\"len(flipping_numbers_to_be_sampled) = {numb_flipping_values}\")\n",
        "\n",
        "    # Data for the graph\n",
        "    x_data = np.arange(num_coins_per_round + 1)\n",
        "    print(f\"x_data = {x_data} \\n\")\n",
        "    y_data =  np.arange(numb_flipping_values)\n",
        "    print(f\"y_data = {y_data} \\n\")\n",
        "\n",
        "    # Create a meshgrid for the x and y coordinates of the bars\n",
        "    _xx, _yy = np.meshgrid(x_data, y_data)\n",
        "    print(f\"_xx = {_xx} \\n\")\n",
        "    print(f\"_yy = {_yy} \\n\")\n",
        "    x_pos, y_pos = _xx.ravel(), _yy.ravel()\n",
        "    print(f\"x_pos = {x_pos} \\n\")\n",
        "    print(f\"y_pos = {y_pos} \\n\")\n",
        "    z_pos = np.zeros_like(x_pos)  # All bars start at z=0\n",
        "\n",
        "    z_heights = 1.0 * np.zeros((numb_flipping_values, num_coins_per_round + 1)) # z_heights initialization\n",
        "    print(f\"z_heights initialized = {z_heights} \\n\")\n",
        "\n",
        "\n",
        "    for index_num_repetitions in range(numb_flipping_values):\n",
        "        print(\"\\n=============================\\n\")\n",
        "        print(f\"index_num_repetitions = {index_num_repetitions}\")\n",
        "        num_repetitions = flipping_numbers_to_be_sampled[index_num_repetitions]\n",
        "        print(f\"Flipping number =  {num_repetitions}\")\n",
        "        results = simulate_coin_flips(num_coins_per_round, num_repetitions)\n",
        "        z_heights = calculate_statistics(results, num_coins_per_round, index_num_repetitions, num_repetitions, z_heights)\n",
        "\n",
        "\n",
        "    dz = z_heights.ravel() # Heights of the bars\n",
        "    print(f\"dz = {dz} \\n\\n\")\n",
        "\n",
        "    print(\"Is there a tendency of the sampled distributions\")\n",
        "    print(\"when the number of repetitions increases?\")\n",
        "    for i in range(numb_flipping_values):\n",
        "        print(f\"Number of repetitions {flipping_numbers_to_be_sampled[i]}: sampled distribution{z_heights[i]}\")\n",
        "\n",
        "    # Create the 3D plot\n",
        "    fig = plt.figure(figsize=(10, 8))\n",
        "    ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "    # Define the dimensions of the bars\n",
        "    dx = dy = 0.6  # Width and depth of the bars\n",
        "\n",
        "    # Plot the 3D bars\n",
        "    ax.bar3d( y_pos, x_pos, z_pos, dx, dy, dz, shade=True)\n",
        "\n",
        "    # Set labels and title\n",
        "    ax.set_xlabel('Number of Repetitions (10^x)')\n",
        "    ax.set_ylabel('Number of heads')\n",
        "    ax.set_zlabel('Relative Frequency')\n",
        "    ax.set_title('Tendency towards the Binomial Distribution')\n",
        "\n",
        "    # Set the tick labels for the y-axis (number of repetitions)\n",
        "    ax.set_yticklabels([f'10^{i+1}' for i in range(numb_flipping_values)])\n",
        "\n",
        "    # Display the plot\n",
        "    plt.show()\n",
        "    return z_heights #To compare observed with expected\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "    # The binomial expansion\n",
        "    def binomial_expansion(p, q, n):\n",
        "        \"\"\"\n",
        "        Calculates the terms of the binomial expansion (p+q)^n.\n",
        "\n",
        "        Args:\n",
        "            p: The probability of the first outcome.\n",
        "            q: The probability of the second outcome (q = 1 - p).\n",
        "            n: The number of trials.\n",
        "\n",
        "        Returns:\n",
        "            A dictionary where keys are the number of successes (k)\n",
        "            and values are the corresponding probabilities.\n",
        "        \"\"\"\n",
        "        if not math.isclose(p + q, 1.0):\n",
        "            print(\"Warning: p + q should be equal to 1.\")\n",
        "\n",
        "        expansion_terms = {}\n",
        "        for k in range(n + 1):\n",
        "            # Calculate the binomial coefficient (n choose k)\n",
        "            binomial_coeff = math.comb(n, k)\n",
        "\n",
        "            # Calculate the probability of k successes\n",
        "            probability_k = binomial_coeff * (p ** k) * (q ** (n - k))\n",
        "\n",
        "            expansion_terms[k] = probability_k\n",
        "        return expansion_terms\n",
        "\n",
        "# Binomial Expansion for a fair coin (p=0.5, q=0.5)\n",
        "# This gives the Mathematically Expected Binomial Distribution\n",
        "p = 0.5\n",
        "q = 0.5\n",
        "n = num_coins_per_round\n",
        "binomial_probs = binomial_expansion(p, q, n)\n",
        "print(f\"Binomial expansion for (0.5 + 0.5)^{n}:\")\n",
        "for k, prob in binomial_probs.items():\n",
        "    print(f\"  {k} heads: {prob:.4f}\")\n",
        "\n",
        "# Simulate the Binomial Distribution for various flipp numbers\n",
        "# to unveil the tendency towards a limit, if only it exists.\n",
        "# The matrix with all sampled distribution is returned.\n",
        "z_heights = plot_hyper_distribution(num_coins_per_round)\n",
        "\n",
        "# Contrast of  expected with expected\n",
        "print(\"\\nComparsion between the simulated and expected Binomial Distributions\")\n",
        "# The last observed distribution is the simulated estimation of the limit\n",
        "lastRow = len(z_heights)-1\n",
        "for k, prob in binomial_probs.items():\n",
        "    print(f\"{k} heads, observed: {prob:.4f}       expected: {z_heights[lastRow, k]}\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dtloQvohx9x1"
      },
      "source": [
        "> **Ejercicio.** Procura que el programa anterior genere un gráfico con las escalas correctas para cada eje. El número de repeticiones debe ser `[10, 100, 1000, 10000]`, dado por la matriz unidimensional `flipping_numbers_to_be_sampled`. El número de caras debe ir de `0` a `num_coins_per_round = 20`. El eje de frecuencia relativa muestra correctamente los valores entre 0 y 1.\n",
        "\n",
        "> **Respuesta.** La documentación para gráficos 3D parece estar incompleta. Mientras tanto, se proponen algunos ajustes menores en el siguiente código:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "26DV5nFJx9x1"
      },
      "outputs": [],
      "source": [
        "# Program tendencyToBinomialGraphGeneral3.py\n",
        "# This program shows the tendency of\n",
        "# the sampled distribution of the number of heads\n",
        "# and compares its limit with\n",
        "# the mathematically expected distribution\n",
        "\n",
        "# Libraries and local rename\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np # Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "\n",
        "\n",
        "# Parameters for the simulation\n",
        "flipping_numbers_to_be_sampled = [10, 100, 1000, 10000]\n",
        "num_coins_per_round  = 20\n",
        "\n",
        "# Simulate coin flips\n",
        "# Returns an array with the number of heads per round\n",
        "def simulate_coin_flips(num_coins_per_round, num_repetitions):\n",
        "    results = []\n",
        "    for _ in range(num_repetitions):\n",
        "        heads_in_round = 0\n",
        "        for _ in range(num_coins_per_round):\n",
        "            # 0 for tails, 1 for heads\n",
        "            if random.choice([0, 1]) == 1:\n",
        "                heads_in_round += 1\n",
        "        results.append(heads_in_round)\n",
        "    return results\n",
        "\n",
        "\n",
        "# Calculate statistics\n",
        "# Returns the sorted distribution of heads\n",
        "# as an array with num_heads and another with the corresponding  relative frequency\n",
        "def calculate_statistics(results, num_coins_per_round, index_num_repetitions, num_repetitions, z_heights):\n",
        "    print(\"\\n calculate_statistics\")\n",
        "    total_heads = sum(results)\n",
        "    proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "    heads_distribution = Counter(results)\n",
        "\n",
        "    # Print the results\n",
        "    print(f\"Simulation of {num_repetitions} rounds \")\n",
        "    print(f\"with {num_coins_per_round} coins per round:\")\n",
        "    print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "    print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "    print(\"\\nDistribution of heads:\")\n",
        "    # Sort the distribution for better readability\n",
        "    sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "    for num_heads, count in sorted_distribution.items():\n",
        "        relative_frequency = count/num_repetitions\n",
        "        print(f\"{num_heads} heads: {count} times,   {relative_frequency} relative frequency\")\n",
        "        if num_heads <= num_coins_per_round and index_num_repetitions < len(flipping_numbers_to_be_sampled):\n",
        "            z_heights[index_num_repetitions, num_heads] = relative_frequency\n",
        "            print(f\"z_heights[{index_num_repetitions},{num_heads}] = {z_heights[index_num_repetitions, num_heads]}\")\n",
        "\n",
        "    print(f\"z_heights  {z_heights}\")\n",
        "    return z_heights\n",
        "\n",
        "\n",
        "# Find and plot the observed distribution of the number of heads\n",
        "# for various flip values for a fix number of coins.\n",
        "def plot_hyper_distribution(num_coins_per_round):\n",
        "    print(\"plot_hyper_distribution(num_coins_per_round):\")\n",
        "    print(f\"num_coins_per_round = {num_coins_per_round}\")\n",
        "    print(f\"flipping_numbers_to_be_sampled = {flipping_numbers_to_be_sampled}\")\n",
        "    numb_flipping_values = len(flipping_numbers_to_be_sampled)\n",
        "    print(f\"len(flipping_numbers_to_be_sampled) = {numb_flipping_values}\")\n",
        "\n",
        "    # Data for the graph\n",
        "    x_data = np.arange(num_coins_per_round + 1)\n",
        "    print(f\"x_data = {x_data} \\n\")\n",
        "    y_data =  np.arange(numb_flipping_values)\n",
        "    print(f\"y_data = {y_data} \\n\")\n",
        "\n",
        "    # Create a meshgrid for the x and y coordinates of the bars\n",
        "    _xx, _yy = np.meshgrid(x_data, y_data)\n",
        "    print(f\"_xx = {_xx} \\n\")\n",
        "    print(f\"_yy = {_yy} \\n\")\n",
        "    # Interchange for the graph\n",
        "    x_pos, y_pos =  _yy.ravel(),_xx.ravel()\n",
        "    print(f\"x_pos = {x_pos} \\n\")\n",
        "    print(f\"y_pos = {y_pos} \\n\")\n",
        "    z_pos = np.zeros_like(x_pos)  # All bars start at z=0\n",
        "\n",
        "    z_heights = 1.0 * np.zeros((numb_flipping_values, num_coins_per_round + 1)) # z_heights initialization\n",
        "    print(f\"z_heights initialized = {z_heights} \\n\")\n",
        "\n",
        "\n",
        "    for index_num_repetitions in range(numb_flipping_values):\n",
        "        print(\"\\n=============================\\n\")\n",
        "        print(f\"index_num_repetitions = {index_num_repetitions}\")\n",
        "        num_repetitions = flipping_numbers_to_be_sampled[index_num_repetitions]\n",
        "        print(f\"Flipping number =  {num_repetitions}\")\n",
        "        results = simulate_coin_flips(num_coins_per_round, num_repetitions)\n",
        "        z_heights = calculate_statistics(results, num_coins_per_round, index_num_repetitions, num_repetitions, z_heights)\n",
        "\n",
        "\n",
        "    dz = z_heights.ravel() # Heights of the bars\n",
        "    print(f\"dz = {dz} \\n\\n\")\n",
        "\n",
        "    print(\"Is there a tendency of the sampled distributions\")\n",
        "    print(\"when the number of repetitions increases?\")\n",
        "    for i in range(numb_flipping_values):\n",
        "        print(f\"Number of repetitions {flipping_numbers_to_be_sampled[i]}: sampled distribution{z_heights[i]}\")\n",
        "\n",
        "    # Create the 3D plot\n",
        "    fig = plt.figure(figsize=(10, 8))\n",
        "    ax = fig.add_subplot(111, projection='3d')\n",
        "\n",
        "    # Define the dimensions of the bars\n",
        "    dx = dy = 0.6  # Width and depth of the bars\n",
        "\n",
        "    # Plot the 3D bars\n",
        "    ax.bar3d( x_pos, y_pos, z_pos, dx, dy, dz, shade=True)\n",
        "\n",
        "    # Set labels and title\n",
        "    ax.set_xlabel('Number of Repetitions = (10^(x+1))')\n",
        "\n",
        "    ax.set_ylabel('Number of heads - 1')\n",
        "    ax.set_zlabel('Relative Frequency')\n",
        "    ax.set_title('Tendency towards the Binomial Distribution')\n",
        "\n",
        "    # Set the tick labels for the y-axis (number of repetitions)\n",
        "    # ax.set_xticklabels([f'10^{i+1}' for i in range(numb_flipping_values)])\n",
        "\n",
        "    # Display the plot\n",
        "    plt.show()\n",
        "    return z_heights\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# The binomial expansion\n",
        "def binomial_expansion(p, q, n):\n",
        "    \"\"\"\n",
        "    Calculates the terms of the binomial expansion (p+q)^n.\n",
        "\n",
        "    Args:\n",
        "        p: The probability of the first outcome.\n",
        "        q: The probability of the second outcome (q = 1 - p).\n",
        "        n: The number of trials.\n",
        "\n",
        "    Returns:\n",
        "        A dictionary where keys are the number of successes (k)\n",
        "        and values are the corresponding probabilities.\n",
        "    \"\"\"\n",
        "    if not math.isclose(p + q, 1.0):\n",
        "        print(\"Warning: p + q should be equal to 1.\")\n",
        "\n",
        "    expansion_terms = {}\n",
        "    for k in range(n + 1):\n",
        "        # Calculate the binomial coefficient (n choose k)\n",
        "        binomial_coeff = math.comb(n, k)\n",
        "\n",
        "        # Calculate the probability of k successes\n",
        "        probability_k = binomial_coeff * (p ** k) * (q ** (n - k))\n",
        "\n",
        "        expansion_terms[k] = probability_k\n",
        "    return expansion_terms\n",
        "\n",
        "# Binomial Expansion for a fair coin (p=0.5, q=0.5)\n",
        "# This gives the Mathematically Expected Binomial Distribution\n",
        "p = 0.5\n",
        "q = 0.5\n",
        "n = num_coins_per_round\n",
        "binomial_probs = binomial_expansion(p, q, n)\n",
        "print(f\"Binomial expansion for (0.5 + 0.5)^{n}:\")\n",
        "for k, prob in binomial_probs.items():\n",
        "    print(f\"  {k} heads: {prob:.4f}\")\n",
        "\n",
        "# Simulate the Binomial Distribution for various flipp numbers\n",
        "# to unveil the tendency towards a limit, if only it exists.\n",
        "# The matrix with all sampled distribution is returned.\n",
        "z_heights = plot_hyper_distribution(num_coins_per_round)\n",
        "\n",
        "# Contrast of  expected with expected\n",
        "print(\"\\nComparsion between the simulated and expected Binomial Distributions\")\n",
        "# The last observed distribution is the simulated estimation of the limit\n",
        "lastRow = len(z_heights)-1\n",
        "for k, prob in binomial_probs.items():\n",
        "    print(f\"{k} heads, Observed: {prob:.4f}  Expected: {z_heights[lastRow, k]}\")\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nlno7jqOx9x2"
      },
      "source": [
        "> **Desafío.** El código del programa anterior `tendencyToBinomialGraphGeneral3.py` funciona casi a la perfección, pero parece muy desestructurado. Provoca fatiga. Estructúrelo con inteligencia para que realizar cambios sea fácil y natural. En la jerga, decimos: desarrollar un software evolutionable.\n",
        "\n",
        "> **CONCLUSIÓN PARCIAL.** Hemos descubierto que la frecuencia relativa de caras y su distribución tienden a un límite que se caracteriza naturalmente por un modelo matemático: la Distribución Binomial. De esta manera, hemos relacionado la teoría con la observación y hemos descubierto que su correspondencia es bastante buena.\n",
        "\n",
        "¿De qué sirve en la Ciencia el hallazgo de la Distribución Binomial como límite de las distribuciones binomiales observadas?\n",
        "\n",
        "# LA BÚSQUEDA DE LA VERDAD\n",
        "\n",
        "Uno crece con la ilusión de que la Ciencia nos mostrará la verdad y de que siempre sabremos la verdadera respuesta a la pregunta: ¿Es correcta esta teoría? De esa manera, imaginamos la verdad en uno de dos valores: Sí o No. Veamos que cuando la aleatoriedad es un factor importante, como en toda disciplina aplicada, debemos cambiar nuestro enfoque de una manera que surja directamente de nuestros procedimientos.\n",
        "\n",
        "Supongamos que debemos decidir si la teoría $p = 0.5$ es verdadera dado que hemos lanzado una moneda 20 veces y hemos obtenido 14 caras y 6 cruces. En general, todos los estudios científicos pueden reformularse como una comparación entre lo que uno piensa y lo que ve, entre lo esperado según una creencia dada y lo observado según el experimento, cuando se controlan todos los factores importantes. Aquí tenemos:\n",
        "\n",
        "> Creencia: $H_o$ que dice $p = 0.5$  \n",
        "> Observado: 14 caras de 20.\n",
        "\n",
        "Para tomar una decisión, la primera tarea es calcular la $H_0$. Esto implica recopilar demasiados datos para estimar la distribución de caras cuando jugamos con 20 monedas. Recordemos lo que hemos aprendido hasta ahora:\n",
        "\n",
        "***Es cierto que la aleatoriedad impide nuestra capacidad de predecir qué ocurrirá a continuación. Sin embargo, existen tendencias hacia un límite en observables de conjunto, como la proporción de caras, la moda y la media del número de caras, y la silueta de la distribución de caras. Para reafirmar las tendencias, basta con aumentar el número de experimentos. Las tendencias a un límite nos proporcionan cierto grado de estabilidad y robustez, y por eso decimos que 10 000 significa infinito.***\n",
        "\n",
        "Ya hemos calculado la $H_o$ que indica $p= 0,5$. De hecho, hemos descubierto que la distribución observada del número de caras tiende a un límite, que, para 10 000 repeticiones, difiere insignificantemente de la distribución binomial.\n",
        "\n",
        "Reproduzcamos aquí la distribución observada hallada previamente:\n",
        "\n",
        "Expansión binomial para (0,5 + 0,5)^20:\n",
        "\n",
        "0 caras: 0,0000\n",
        "\n",
        "1 cara: 0,0000\n",
        "\n",
        "2 caras: 0,0002\n",
        "\n",
        "3 caras: 0,0011\n",
        "\n",
        "4 caras: 0,0046\n",
        "\n",
        "5 caras: 0,0148\n",
        "\n",
        "6 caras: 0,0370\n",
        "\n",
        "7 caras: 0,0739\n",
        "\n",
        "8 caras: 0,1201\n",
        "\n",
        "9 caras: 0,1602\n",
        "\n",
        "10 caras: 0,1762\n",
        "\n",
        "11 caras: 0,1602\n",
        "\n",
        "12 caras: 0,1201\n",
        "\n",
        "13 caras: 0,0739\n",
        "\n",
        "14 caras: 0,0370\n",
        "\n",
        "15 caras: 0,0148\n",
        "\n",
        "16 caras: 0,0046\n",
        "\n",
        "17 caras: 0,0011\n",
        "\n",
        "18 caras: 0,0002\n",
        "\n",
        "19 caras: 0,0000\n",
        "\n",
        "20 caras: 0,0000\n",
        "\n",
        "Observemos que cada evento tiene una frecuencia relativa baja que, de todos modos, se desvanece hacia los extremos 0 y 20. Más concretamente, nuestra simulación con 10 000 repeticiones no produce eventos con un número de caras en el conjunto 0, 1, 19, 20. Esto no es un milagro, ya que se observa en la vida real:\n",
        "\n",
        "> **Ejemplo.** Supongamos que creamos una muestra aleatoria de 20 personas y registramos su género, masculino o femenino. No esperamos que las 20 personas sean hombres o que todas sean mujeres, ni que haya 19 hombres y 1 mujer, ni 19 mujeres y 1 hombre. Más bien, encontraremos valores en torno a 10 hombres y 10 mujeres. Comentario: Al nacer, hay un poco más de hombres que de mujeres, pero en la edad adulta, podría encontrarse un ligero exceso de mujeres debido a que la mortalidad masculina es ligeramente superior a la femenina. ¿Qué hacemos si entre 20 personas encontramos 18 mujeres y 2 hombres? Siempre realizaremos una nueva muestra, una nueva observación. Si la situación persiste, preguntaremos: ¿Dónde están los hombres? Y entonces, responderán que están en el ejército o en el campo.\n",
        "\n",
        "¿Qué haremos una vez calculada la $H_o$ y tengamos una distribución de caras?\n",
        "\n",
        "Dividimos el mundo en dos regiones: la primera debe apoyar la $H_o$ invitando a aceptarla, mientras que la segunda debe levantar sospechas, invitando a rechazarla. ¿Existe alguna regla para dividir el mundo entre regiones de rechazo y de aceptación? No. No la hay. Esto significa que los seres humanos dividen el mundo según sus objetivos o su libre albedrío.\n",
        "\n",
        "Clasificar un evento como sospechoso no es una decisión objetiva. Es subjetiva. Hemos dicho que los valores 0, 1, 19 y 20 son sospechosos porque la frecuencia relativa de estos eventos es nula. Pero esta es solo una opción. En la vida real, las personas pueden declarar proporciones muy diferentes de eventos sospechosos.\n",
        "\n",
        "> **Ejemplo.** Imaginemos dos candidatos, A y B. Aparecieron en un programa de televisión. Son totalmente desconocidos, por lo que ninguno es el favorito. La probabilidad de votar por uno de ellos en ese momento es de 0,5. Pero si, después del programa, mucha gente habla con emoción sobre el candidato B y nadie recuerda al candidato A, sabemos que la gente tiene un candidato. Todos querrían saber qué dice y, tras escuchar su propuesta, exclamarían: \"¡Este candidato sabe cómo atar los cabos!\". La descripción estadística correspondiente asignaría 0,95 a la probabilidad de votar por el candidato B y 0,05 a la del candidato A. Por lo tanto, se rechaza la hipótesis inicial de indiferencia y se adopta una nueva. Esto implica que el candidato A estudiará el discurso de B e implementará una política ganadora. De hecho, el candidato A hará sonar las alarmas cuando las encuestas indiquen alguna ventaja para B, por lo que la política parece funcionar con una proporción de rechazo de eventos igual a 0,99 para la diferencia en perspectivas de votos.\n",
        "\n",
        "Si partimos de una suposición que llamamos hipótesis nula, $H_o$, usamos nuestro libre albedrío para clasificar los eventos como normales o de aceptación, de rechazo o extraños. Un evento normal invita a aceptar la hipótesis nula, mientras que un evento extraño invita a rechazarla y proponer otra hipótesis. Los división es arbitraria y subjetiva. Toda clasificación de eventos, bien como normales o bien como anormales, es una decisión humana, una responsabilidad humana. Enfaticémoslo:\n",
        "\n",
        ">>  La Ciencia es una creación humana, una responsabilidad humana.   \n",
        ">> La Ciencia se compone de obras de arte, no de dogmas.\n",
        "\n",
        "\n",
        "**La Ciencia ha optado por la siguiente regla predeterminada: la proporción de eventos ordinarios se define como 0,95 y la de eventos extraños, como 0,05.** Para una distribución central, similar a una campana, cuya silueta se asemeja a una montaña de un solo pico que se desvanece en la distancia, los eventos extraños se encuentran en los confines del universo y deben sumar un 5% o 0,05. Si disponemos de muchos datos y un gran descubrimiento, esta barrera podría reducirse a 0,01, o a 0,001 o incluso menos. Es habitual fijar la barrera en 0,05 o 5% porque proporciona una buena proporción de eventos que invitan a revisar las creencias y que pueden encontrarse con muestras de tamaño 20 o 30. Para ser más rigurosos, la barrera debe reducirse a 0,01, lo que requiere muestras de tamaño 100 o 200. Y así sucesivamente.\n",
        "\n",
        "El concepto de extraño no siempre se puede aplicar.\n",
        "\n",
        "> **Ejemplo.** Una ruleta se divide en 360 sectores circulares numerados con la misma probabilidad, 1/360. ¿Existe algún sector que merezca ser llamado extraño? No, no lo hay. ¿Significa esto que no podemos hacer Ciencia con una ruleta? No. En cambio, debemos crear un entorno donde tenga sentido dividir el mundo en ordinario y extraño. El siguiente ejemplo lo explica: El juego consiste en girar la ruleta dos veces y sumar los dos números marcados con la flecha. La suma tendrá tanto valores raros como muy comunes. Por ejemplo, el valor 2 solo tiene una posibilidad, 1 + 1, pero el valor 360 tiene demasiadas posibilidades: 359 + 1, 358 + 2, ..., 180 + 180, 179 + 181, 178 + 182, ... 1 + 359. Es valor 360 es 359 veces más probable que 2. Por lo tanto, tiene sentido decir que 2 está en la región de rechazo y el resto en la de aceptación. Pero ¿de qué $H_o$? De la $H_o$ que indica que todos los eventos en la ruleta son equiprobables.\n",
        "\n",
        "> **Ejemplo.** Apliquemos la regla científica estándar a nuestro caso práctico de lanzar 20 monedas con la probabilidad de cara de 0,5. Definimos que la proporción de eventos raros debe ser 0,05. Como la campana es simétrica y no prestamos atención a un lado específico, dividimos 0,05 entre ambas colas y asignamos 0,025 a cada una. Esto produce la siguiente tabla, en la que comenzamos a acumular desde los extremos:\n",
        "\n",
        "Expansión binomial para $(0.5 + 0.5)^20$:    \n",
        "0 caras: 0.0000 acumulado 0.0    \n",
        "1 cara: 0.0000 acumulado 0.0    \n",
        "2 caras: 0.0002 acumulado 0.0002    \n",
        "3 caras: 0.0011 acumulado 0.0013    \n",
        "4 caras: 0.0046 acumulado 0.0059    \n",
        "5 caras: 0.0148 acumulado 0.0207    \n",
        "6 caras: 0.0370 acumulado 0.0577    \n",
        "7 caras: 0.0739    \n",
        "8 caras: 0.1201    \n",
        "9 caras: 0.1602    \n",
        "10 caras: 0.1762    \n",
        "11 caras: 0,1602    \n",
        "12 caras: 0,1201    \n",
        "13 caras: 0,0739    \n",
        "14 caras: 0,0370 acumulado 0,0577    \n",
        "15 caras: 0,0148 acumulado 0,0207    \n",
        "16 caras: 0,0046 acumulado 0,0059    \n",
        "17 caras: 0,0011 acumulado 0,0013    \n",
        "18 caras: 0,0002 acumulado 0,0002    \n",
        "19 caras: 0,0000 acumulado 0,0    \n",
        "20 caras: 0,0000 acumulado 0,0    \n",
        "\n",
        "\n",
        "El criterio de medida de los eventos raros, igual a 0,05, convierte en extraños, extremos o raros los eventos 0, 1, 2, 3, 4, 5 y 15, 16, 17, 18, 19 y 20, cuyas frecuencias relativas suman 0,0414, casi 0,05. Parece una lista larga. Si esto se corresponde con la altura de las personas, esto ilustra el comportamiento de las mujeres: rechazan a los hombres pequeños, en la cola inferior, y prefieren a los altos, en la superior.\n",
        "\n",
        "> **Ejemplo.** Desarrollemos un programa en Python que represente gráficamente las regiones de aceptación y rechazo cuando la región de rechazo tenga una probabilidad de 0,05.\n",
        "\n",
        "Nuestra idea es usar un gráfico de barras; los eventos comunes se colorearán en azul y los extraños en rojo. Por lo tanto, consultamos la documentación de MatplotLib para gráficos de barras y encontramos el siguiente ejemplo:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "96vPYqapx9x2"
      },
      "outputs": [],
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "\n",
        "fruits = ['apple', 'blueberry', 'cherry', 'orange']\n",
        "counts = [40, 100, 30, 55]\n",
        "bar_labels = ['red', 'blue', '_red', 'orange']\n",
        "bar_colors = ['tab:red', 'tab:blue', 'tab:red', 'tab:orange']\n",
        "\n",
        "ax.bar(fruits, counts, label=bar_labels, color=bar_colors)\n",
        "\n",
        "ax.set_ylabel('fruit supply')\n",
        "ax.set_title('Fruit supply by kind and color')\n",
        "ax.legend(title='Fruit color')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wwfhZDrvx9x2"
      },
      "source": [
        "> **Ejercicio** Ejecute el código que dibuja un diagrama de barras y preste atención a la forma en que se proporcionan los datos.\n",
        "\n",
        "> Respuesta: Los datos son de diversos tipos y deben presentarse en vectores separados, asegurándose que sigan el mismo orden.\n",
        "\n",
        "A partir de este ejemplo, proponemos el siguiente código que representa gráficamente nuestra distribución esperada, en la que los eventos de rechazo o raros se colorean de forma distinta a los de aceptación o normales:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "X_6Z1hDex9x3"
      },
      "outputs": [],
      "source": [
        "# Program binomialDistriColoredTails.py\n",
        "# Binomial Expansion for a fair coin (p=0.5, q=0.5)\n",
        "# This gives the Mathematically Expected Binomial Distribution\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# The binomial expansion\n",
        "def binomial_expansion(p, q, n):\n",
        "    \"\"\"\n",
        "    Calculates the terms of the binomial expansion (p+q)^n.\n",
        "\n",
        "    Args:\n",
        "        p: The probability of the first outcome.\n",
        "        q: The probability of the second outcome (q = 1 - p).\n",
        "        n: The number of trials.\n",
        "\n",
        "    Returns:\n",
        "        A dictionary where keys are the number of successes (k)\n",
        "        and values are the corresponding probabilities.\n",
        "    \"\"\"\n",
        "    if not math.isclose(p + q, 1.0):\n",
        "        print(\"Warning: p + q should be equal to 1.\")\n",
        "\n",
        "    expansion_terms = {}\n",
        "    for k in range(n + 1):\n",
        "        # Calculate the binomial coefficient (n choose k)\n",
        "        binomial_coeff = math.comb(n, k)\n",
        "\n",
        "        # Calculate the probability of k successes\n",
        "        probability_k = binomial_coeff * (p ** k) * (q ** (n - k))\n",
        "\n",
        "        expansion_terms[k] = probability_k\n",
        "    return expansion_terms\n",
        "\n",
        "# Binomial Expansion for a fair coin (p=0.5, q=0.5)\n",
        "# This gives the Mathematically Expected Binomial Distribution\n",
        "p = 0.5\n",
        "q = 0.5\n",
        "n = num_coins_per_round = 20\n",
        "binomial_probs = binomial_expansion(p, q, n)\n",
        "cumulate_prob = 0.0\n",
        "print(f\"Binomial expansion for (0.5 + 0.5)^{n}:\")\n",
        "for k, prob in binomial_probs.items():\n",
        "    cumulate_prob += prob\n",
        "    print(f\"  {k} heads: {prob:.4f}     cumulate_prob: {cumulate_prob} \")\n",
        "\n",
        "#######  The graphic with strange and normal events distinctly colored.\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "\n",
        "k_class = [] # Horizontal label\n",
        "counts = [] # vertical values\n",
        "bar_labels = [] # colors of bars\n",
        "bar_colors = []\n",
        "\n",
        "left_tail = 0.0\n",
        "right_tail = 0.0\n",
        "\n",
        "# Coloring\n",
        "for k, prob in binomial_probs.items():\n",
        "    k_class.append(k)\n",
        "    counts.append(prob)\n",
        "    left_tail += prob\n",
        "    if left_tail < 0.25:\n",
        "        bar_labels.append('red')\n",
        "        bar_colors.append('tab:red')\n",
        "    if ( (left_tail > 0.25) & (left_tail < 0.75)):\n",
        "        bar_labels.append('blue')\n",
        "        bar_colors.append('tab:blue')\n",
        "    if left_tail > 0.75:\n",
        "        bar_labels.append('red')\n",
        "        bar_colors.append('tab:red')\n",
        "\n",
        "\n",
        "ax.bar(k_class, counts, label=bar_labels, color=bar_colors)\n",
        "\n",
        "ax.set_ylabel('probability')\n",
        "ax.set_title('Binomial Distribution with rejection regions in red')\n",
        "# ax.legend(title='Fruit color')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5PJ1-5Pxx9x3"
      },
      "source": [
        "> **Ejercicio.** Ejecute el código anterior y evalúelo.\n",
        "\n",
        ">> **Respuesta.** El código colorea todas las barras correctamente excepto una.\n",
        "\n",
        "> **Ejercicio.** Nuestro código anterior produce un gráfico con regiones rojas asimétricas. Corrija esto.\n",
        "\n",
        ">> **Respuesta.** El siguiente código produce un gráfico simétrico cuando la probabilidad de eventos raros es 0,05. En realidad, debido a la discreción de los datos, la probabilidad de eventos raros es el valor máximo posible, menor que 0,05. Su valor se añade al título del gráfico."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Sm1VgJkex9x3"
      },
      "outputs": [],
      "source": [
        "# Program binomialDistriColoredTails2.py\n",
        "# Binomial Expansion for a fair coin (p=0.5, q=0.5)\n",
        "# This gives the Mathematically Expected Binomial Distribution\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# The binomial expansion\n",
        "def binomial_expansion(p, q, n):\n",
        "    \"\"\"\n",
        "    Calculates the terms of the binomial expansion (p+q)^n.\n",
        "\n",
        "    Args:\n",
        "        p: The probability of the first outcome.\n",
        "        q: The probability of the second outcome (q = 1 - p).\n",
        "        n: The number of trials.\n",
        "\n",
        "    Returns:\n",
        "        A dictionary where keys are the number of successes (k)\n",
        "        and values are the corresponding probabilities.\n",
        "    \"\"\"\n",
        "    if not math.isclose(p + q, 1.0):\n",
        "        print(\"Warning: p + q should be equal to 1.\")\n",
        "\n",
        "    expansion_terms = {}\n",
        "    for k in range(n + 1):\n",
        "        # Calculate the binomial coefficient (n choose k)\n",
        "        binomial_coeff = math.comb(n, k)\n",
        "\n",
        "        # Calculate the probability of k successes\n",
        "        probability_k = binomial_coeff * (p ** k) * (q ** (n - k))\n",
        "\n",
        "        expansion_terms[k] = probability_k\n",
        "    return expansion_terms\n",
        "\n",
        "# Binomial Expansion for a fair coin (p=0.5, q=0.5)\n",
        "# This gives the Mathematically Expected Binomial Distribution\n",
        "p = 0.5\n",
        "q = 0.5\n",
        "n = num_coins_per_round = 20\n",
        "binomial_probs = binomial_expansion(p, q, n)\n",
        "cumulate_prob = 0.0\n",
        "print(f\"Binomial expansion for (0.5 + 0.5)^{n}:\")\n",
        "for k, prob in binomial_probs.items():\n",
        "    cumulate_prob += prob\n",
        "    print(f\"  {k} heads: {prob:.4f}     cumulate_prob: {cumulate_prob} \")\n",
        "\n",
        "#######  The graphic with rare and normal events distinctly colored.\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "\n",
        "k_class = []\n",
        "counts = []\n",
        "bar_labels = []\n",
        "bar_colors = []\n",
        "\n",
        "left_tail = 0.0\n",
        "real_alpha_half = -1.0\n",
        "\n",
        "epsilon = 1e-7\n",
        "for k, prob in binomial_probs.items():\n",
        "    k_class.append(k)\n",
        "    counts.append(prob)\n",
        "    left_tail += prob\n",
        "    if left_tail < 0.25:\n",
        "        bar_labels.append('red')\n",
        "        bar_colors.append('tab:red')\n",
        "        real_alpha_half = left_tail\n",
        "        red_area = 2 * real_alpha_half\n",
        "        print(f\"{k}  left_tail = {left_tail}\")\n",
        "    if  ((left_tail > 0.25) and  (1-left_tail  + epsilon > real_alpha_half)) :\n",
        "        bar_labels.append('blue')\n",
        "        bar_colors.append('tab:blue')\n",
        "        print(f\" {k}  {1-left_tail + epsilon} > {real_alpha_half}  blue\")\n",
        "    if 1-left_tail + epsilon <= real_alpha_half:\n",
        "        bar_labels.append('red')\n",
        "        bar_colors.append('tab:red')\n",
        "        print(f\" {k}  {1-left_tail + epsilon} <= {real_alpha_half}  red\")\n",
        "\n",
        "ax.bar(k_class, counts, label=bar_labels, color=bar_colors)\n",
        "\n",
        "ax.set_ylabel('Probability')\n",
        "ax.set_xlabel('Number of heads')\n",
        "ax.set_title(f\"Binomial Distribution with rejection regions in red, area = {red_area:.4f}\")\n",
        "# ax.legend(title='Bar color')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u0zlNcrXx9x3"
      },
      "source": [
        "> **Desafío.** El código anterior funciona cuando la proporción de la región de rechazo es 0,05. Este valor se denomina oficialmente *significancia*, lo que indica que cuanto menor es, más raro es un evento y, por lo tanto, más sospechoso de generar un gran descubrimiento. Generalice este código para cualquier significancia.\n",
        "\n",
        "# ¿Ley o consejo?\n",
        "\n",
        "La subjetividad del procedimiento para dividir el mundo de los eventos en dos subconjuntos, correspondientes a la aceptación o al rechazo, impone una conclusión: la Ciencia no puede ser una ley, sino que sus veredictos son solo consejos a tener en cuenta, ya que un resultado puede explicarse de muchas maneras, un hecho endémico de nuestro tema.\n",
        "\n",
        "> **Ejemplo.** Con nuestro criterio aceptado para distinguir entre lo normal y lo extraño, muchos eventos pueden explicarse mediante diversas hipótesis nulas diferentes. Ilustremos este hecho mostrando que un evento dado puede ser normal según la $H_o$ que establece p = 0,5 = 1/2 y también según la hipótesis que declara $p = 2/3$. Nuestro evento se da por un número de caras igual a 14 de 20. Según la tabla anterior, 14 es un valor normal si consideramos que la probabilidad de cara es 0,5. Demostremos ahora que también es normal cuando p = 2/3. Para ello, simulemos esta probabilidad."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kOYCAmISx9x4"
      },
      "outputs": [],
      "source": [
        "#  Program coinsProbOfHeadsTwoThirds.py\n",
        "\n",
        "# Libraries and local rename\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "\n",
        "# Parameters for the simulation\n",
        "num_coins_per_round = 20\n",
        "num_repetitions = 10000\n",
        "\n",
        "# Simulate coin flips\n",
        "results = []\n",
        "for _ in range(num_repetitions):\n",
        "    heads_in_round = 0\n",
        "    for _ in range(num_coins_per_round):\n",
        "        # 0 for tails, 1 for heads\n",
        "        if random.choice([0, 1, 1]) == 1:\n",
        "            heads_in_round += 1\n",
        "    results.append(heads_in_round)\n",
        "\n",
        "# Calculate statistics\n",
        "total_heads = sum(results)\n",
        "proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "heads_distribution = Counter(results)\n",
        "\n",
        "# Arrays to keep values to be graphed\n",
        "x_values = []\n",
        "y_values = []\n",
        "\n",
        "# Print the results\n",
        "print(\"Heads is 1 in a random choice between 0, 1 \")\n",
        "print(f\"Simulation of {num_repetitions} rounds \")\n",
        "print(f\"with {num_coins_per_round} coins per round:\")\n",
        "print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "print(\"\\nDistribution of heads per round:\")\n",
        "# Sort the distribution for better readability\n",
        "sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    x_values.append(num_heads)\n",
        "    y_values.append(count)\n",
        "    print(f\"  {num_heads} heads: {count} times\")\n",
        "\n",
        "#Plot the function\n",
        "plt.plot(x_values, y_values, label=\"Heads_distribution\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"Number of heads\")\n",
        "plt.ylabel(\"Count\")\n",
        "plt.title(\"Graph of heads distribution\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2a2pUlJjx9x4"
      },
      "source": [
        ">> Vemos que 14 caras se encuentran, con casi la frecuencia más alta, en la moda de la distribución. Por lo tanto, es normal según nuestro criterio. Por lo tanto, el dato observado de 14 caras puede explicarse por dos hipótesis: la primera p = 0,5, la segunda p = 2/3 = 0,666...\n",
        "\n",
        "En conclusión, cuando la Ciencia presenta un modelo que no puede rechazarse con los datos disponibles, no garantiza que el modelo sea verdadero. Solo afirma que el modelo es compatible con los datos. Esto es una forma de decir que se agradecen más explicaciones. En cualquier caso, cuando demasiadas teorías son compatibles con los datos disponibles, reconocemos que el campo de investigación es bastante rudimentario y se requiere más trabajo y estudio para identificar una teoría ganadora.\n",
        "\n",
        "# El Algoritmo Científico\n",
        "\n",
        "Nuestro procedimiento para estudiar las creencias es casi universal y puede aplicarse a una amplia gama de situaciones. ¿Podemos abstraerlo para obtener un método formal?\n",
        "\n",
        "> **Ejercicio.** Reflexionando sobre nuestro caso práctico de $H_o$, que indica $p = 0.05$, formule un procedimiento o algoritmo para el estudio científico de hipótesis nulas ante la aleatoriedad:\n",
        "\n",
        "> **Respuesta.** La siguiente es un procedimiento o algoritmo para estudiar científicamente las creencias:\n",
        "\n",
        "1. Observe el mundo para extraer posibles leyes o tendencias que se conviertan en una creencia.\n",
        "\n",
        "2. Si es posible, formule la creencia a estudiar en un lenguaje operativo que pueda simularse o implementarse en un laboratorio.\n",
        "\n",
        "3. Considere la aleatoriedad como la primera explicación posible de sus datos y creencia. Esta es la hipótesis nula, $H_o$.\n",
        "\n",
        "4. Programe y simule su $H_o$ para estimar la distribución de la observable de interés.\n",
        "\n",
        "5. Divida el mundo de eventos en dos partes: una que apoya la creencia o $H_o$ (la hipótesis nula) y otra que la rechaza. Cuando la distribución de la característica medida tiene forma de campana, la región alrededor de la moda, que cubre el 95%, es la región de aceptación de la $H_o$. La región que cubre las colas de la campana es la región de rechazo. El criterio científico predeterminado asigna el 95% a la región de aceptación y el 5% a la región de rechazo.\n",
        "\n",
        "6. Emita un veredicto: si el evento observado se encuentra en la región de aceptación, acepte la $H_o$. De lo contrario, rechácela. Una aceptación no significa que la $H_o$ sea la explicación de los datos, sino solo que los datos y la creencia son compatibles. Del mismo modo, un rechazo no significa que los datos no se expliquen por la $H_o$, sino que se explican mejor mediante otras hipótesis que es necesario formular.\n",
        "\n",
        "7. Interprete el veredicto.\n",
        "\n",
        "> **Ejemplo.** Nuestro juego con 20 monedas representa la situación del tráfico en un carril y un país cuando la velocidad tiene una distribución de campana en torno a los 60 km/h. Por lo tanto, 1 cara corresponde a una velocidad de 6 kilómetros por hora, y 14 caras significan una velocidad de 84 km/h, que en este carril, zona y país es normal, y el cliente no pagará una multa.\n",
        "\n",
        "# La elegancia de la distribución z\n",
        "\n",
        "La estadística es una herencia antigua que consiste en razonamiento matemático puro que asume que podemos definir a priori probabilidades cuya verificación experimental requiere generadores aleatorios perfectos y muchos experimentos cercanos al infinito. Esto es exactamente lo que se requiere cuando decimos que la probabilidad de cara es 0,5. Ahora bien, la estadística es muy útil en la vida real porque las conclusiones valiosas son estables frente al ruido, la inexactitud y las aproximaciones.\n",
        "\n",
        "Una característica de la herencia antigua es su elegancia. Para comprobarlo, veamos una caracterización del método científico en presencia de ruido que provoca que los datos incluyan componentes aleatorios. La aleatoriedad surge cuando diversos factores, que pueden ser deterministas, interactúan de forma compleja, lo que dificulta predecir el futuro. La caracterización del método científico es la siguiente:\n",
        "\n",
        "**La Ciencia se centra en la medición de la diferencia entre lo que se piensa, la hipótesis nula, y lo que se observa en un experimento, en un entorno controlado. Si la diferencia es demasiado alta, se invita a concluir que lo que se piensa es incorrecto, se rechaza la hipótesis nula y se debe idear una nueva explicación. Pero si la diferencia es pequeña, se declara que carecemos de razones para cambiar de opinión, y se acepta la hipótesis nula. **\n",
        "\n",
        "En relación con nuestra simulación con monedas, si lanzamos una moneda justa 20 veces, esperamos un número de caras que se muevan simétricamente alrededor de 10, lo que da lugar a una distribución similar a una campana. Por ejemplo, si encontramos 14 caras, la diferencia con lo esperado, bajo la hipótesis nula de imparcialidad de la moneda, es 4. Pero debemos avanzar un paso más.\n",
        "\n",
        "Apliquemos la siguiente observación: todas las campanas tienen la misma silueta. ¿Cómo formalizamos esta observación? Debemos liberar la silueta de las escalas, tanto horizontales, dadas por el número de monedas, como verticales, dadas por las frecuencias relativas. Los pensadores antiguos encontraron la manera de hacerlo: la diferencia entre lo observado y lo esperado debe dividirse por la desviación estándar de la campana,  que denotamos como $s$, la cual es la raíz cuadrada de la varianza y sirve como una medida de su dispersión.\n",
        "\n",
        "Terminamos con una medida de discrepancia $d$ entre lo observado y lo esperado como:\n",
        "\n",
        "$d = \\frac{Observado - Esperado}{DesviaciónEstándar}$\n",
        "\n",
        "En nuestro caso, medimos la discrepancia entre el número observado de caras, digamos 14, y la media, 10, que el valor promedio esperado del número de caras cuando la probabilidad de cara es 0,5 y el número de monedas por ronda es 20. La discrepancia entre lo observado y lo esperado en unidades de desviaciones estándar es:\n",
        "\n",
        "$z = \\frac{14-10}{s}$\n",
        "\n",
        "Para determinar si el valor observado, 14, es normal o extremo, debemos hallar la distribución de esta medida, determinar qué es normal y qué es extremo y, en consecuencia, clasificar nuestro resultado observado. Esta distribución se denomina distribución z. La desviación estándar s se calcula a partir de un número finito de observaciones y varía de un experimento a otro. Pero no debemos temer, ya que el error causado no es fatal; todo el procedimiento es estable ante esta variación. En cualquier caso, en nuestras simulaciones consideramos muchos eventos, alrededor de 10 000, y esperamos aproximarnos mucho a las expectativas matemáticas.\n",
        "\n",
        "Para avanzar con nuestro plan, necesitamos el código para la desviación estándar de un conjunto de datos dado.\n",
        "\n",
        "> **Ejemplo.** Solicitamos a Gemini:\n",
        "\n",
        "> Por favor, ayúdenme con el código de Python para calcular la desviación estándar de una matriz de números llamada 'y_values'.\n",
        "\n",
        "> En respuesta, Gemini mostró el siguiente código:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WWB8ffzdx9x4"
      },
      "outputs": [],
      "source": [
        "# program standardDeviation.py\n",
        "# By Gemini\n",
        "import statistics\n",
        "\n",
        "# Example, array with numbers\n",
        "y_values = [10, 12, 23, 23, 16, 23, 21, 16]\n",
        "\n",
        "# Berechne die Standar Deviation\n",
        "std_dev = statistics.stdev(y_values)\n",
        "\n",
        "# Print results\n",
        "print(f\"The array of numbers is: {y_values}\")\n",
        "print(f\"The standard deviation of y_values is: {std_dev:.4f}\")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iWzVkYgux9x4"
      },
      "source": [
        "> Gemini añadió el resultado del cálculo.\n",
        ">\n",
        "> Resultados:\n",
        ">>\n",
        ">> El array de números es: [10, 12, 23, 23, 16, 23, 21, 16]\n",
        ">>\n",
        ">> La desviación estándar de los y-values es: 5,2372\n",
        ">>\n",
        "> Vemos que Python tiene una biblioteca con un procedimiento para calcular la desviación estándar de un array de datos y, por supuesto, la media. Aplicaremos esto al array de resultados en nuestras simulaciones. Advertencia: la literatura distingue dos tipos de desviación estándar: el primero para una población, cuando se censan todos los objetos del conjunto universal de observaciones. El segundo es para una muestra, cuando se mide una selección aleatoria de objetos. Cuando el número de datos es grande, superior a 100, la diferencia entre ambos es irrelevante. Por lo tanto, no le prestaremos atención.\n",
        "\n",
        "> **Ejemplo:** Estimemos la distribución z mediante una simulación."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WhvWlSUzx9x5"
      },
      "outputs": [],
      "source": [
        "#  Program zDistribution.py\n",
        "# The Binomial Distribution is estimated by a simulation and drawn,\n",
        "# it is then standardized to produce an estimation of\n",
        "# the z-distribution.\n",
        "\n",
        "\n",
        "# Libraries\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "import statistics\n",
        "\n",
        "# Parameters for the simulation\n",
        "num_coins_per_round = 20\n",
        "num_repetitions = 10000\n",
        "\n",
        "# Simulate coin flips\n",
        "results = []\n",
        "for _ in range(num_repetitions):\n",
        "    heads_in_round = 0\n",
        "    for _ in range(num_coins_per_round):\n",
        "        # 0 for tails, 1 for heads\n",
        "        if random.choice([0, 1]) == 1:\n",
        "            heads_in_round += 1\n",
        "    results.append(heads_in_round)\n",
        "\n",
        "# Calculate statistics\n",
        "total_heads = 0\n",
        "for x in results:\n",
        "    total_heads += x\n",
        "proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "heads_distribution = Counter(results)\n",
        "\n",
        "\n",
        "# Arrays to keep values to be graphed\n",
        "x_values = []\n",
        "y_values = []\n",
        "\n",
        "\n",
        "\n",
        "# Print the results\n",
        "print(\"Heads corresponds with 1 in a random choice between 0, 1 \")\n",
        "print(f\"Simulation of {num_repetitions} rounds \")\n",
        "print(f\"with {num_coins_per_round} coins per round:\")\n",
        "print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "print(\"\\nDistribution of heads per round:\")\n",
        "# Sort the distribution for better readability\n",
        "sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    x_values.append(num_heads)\n",
        "    y_values.append(count)\n",
        "    print(f\"  {num_heads} heads: {count} times\")\n",
        "\n",
        "# Plot the function\n",
        "plt.plot(x_values, y_values, label=\"Heads_distribution\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"Number of heads\")\n",
        "plt.ylabel(\"Count\")\n",
        "plt.title(\"Graph of a heads distribution\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n",
        "\n",
        "#values for the z-distribution, z_values and estimated probability\n",
        "z_values = []\n",
        "p_values = []\n",
        "\n",
        "#the mean number of heads is computed\n",
        "mean = statistics.mean(results)\n",
        "mean2 = 0.5*num_coins_per_round\n",
        "print(f\"Observed mean = {mean}, expected {mean2}\")\n",
        "# The standard deviation of results is computed\n",
        "std_dev = statistics.stdev(results)\n",
        "std_dev_expected = np.sqrt(mean2*0.5) #sqrt(npq)\n",
        "print(f\"Observed Standard Deviation: {std_dev:.4f}, Expected: {std_dev_expected:.4f}\")\n",
        "\n",
        "# The z-distribution\n",
        "# z-transform to measure the difference between observed and expected\n",
        "# Observed = num_heads\n",
        "# Expected = mean2 = np = 20 * 0.5 = 10\n",
        "total_frequency = 0\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    z = (num_heads - mean2) / std_dev # Calculate z-score using the observed mean\n",
        "    z_values.append(z)\n",
        "    p = count/num_repetitions\n",
        "    p_values.append(p)\n",
        "    total_frequency += p\n",
        "    print(f\"  {z:.4f} z_value: {p:.4f} probability\")\n",
        "\n",
        "\n",
        "print(f\"Total frequency= {total_frequency}, expected = 1\")\n",
        "\n",
        "\n",
        "# Plot the estimated z-distribution\n",
        "plt.plot(z_values, p_values, label=\"Estimated z-distribution\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"z = standarized discrepancy between observed and expected\")\n",
        "plt.ylabel(\"Probability\")\n",
        "plt.title(\"Estimated z-distribution\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "\n",
        "# Display the plot\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RAXgg7q7x9x5"
      },
      "source": [
        "> **Conclusión parcial.** La distribución Binomial es discreta. Sin embargo, con frecuencia hemos ajustado su envolvente a una curva que se asemeja a una campana, cuyo nombre técnico es campana de Gauss, que es continua. Estas campanas pueden estar más o menos dispersas, pero el sentido común indica que todas las campanas de Gauss son iguales, en el sentido de que si medimos los eventos en unidades de desviaciones estándar, no podemos distinguirlas. Esto se convierte en riguroso mediante la transformada z, que es el nombre de la fórmula $z$.\n",
        "\n",
        "> **Ejercicio.** Desarrolle el código que muestra las regiones coloreadas de aceptación y rechazo para la transformada z generada por la distribución Binomial con $p = 0.5$ y para cualquier número de monedas.\n",
        "\n",
        ">> **Respuesta.** Le pedimos a Colab que diseñara el código correspondiente con la siguiente instrucción:\n",
        ">>\n",
        ">>> Código para el gráfico de la transformada z que muestra las regiones de aceptación y rechazo coloreadas con una confianza de 0.05\n",
        ">>\n",
        ">> Gemini respondió:\n",
        ">>\n",
        ">>> *Bien, añadiré el código a la celda seleccionada para graficar la transformada z de la distribución binomial, resaltando las regiones de aceptación y rechazo.*\n",
        ">>\n",
        ">> Y publicó el siguiente código:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3VJP80q3x9x5"
      },
      "outputs": [],
      "source": [
        "# Program zDistributionColoredTails.py\n",
        "# This program calculates and plots the z-transform of the Binomial distribution\n",
        "# with acceptance and rejection regions highlighted for a given significance level.\n",
        "# By Gemini\n",
        "\n",
        "# Libraries and local rename\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np # Support for scientific computing\n",
        "from scipy.stats import binom # Import the binomial distribution from scipy\n",
        "\n",
        "# The binomial expansion\n",
        "def binomial_expansion(p, q, n):\n",
        "    \"\"\"\n",
        "    Calculates the terms of the binomial expansion (p+q)^n.\n",
        "\n",
        "    Args:\n",
        "        p: The probability of the first outcome.\n",
        "        q: The probability of the second outcome (q = 1 - p).\n",
        "        n: The number of trials.\n",
        "\n",
        "    Returns:\n",
        "        A dictionary where keys are the number of successes (k)\n",
        "        and values are the corresponding probabilities.\n",
        "    \"\"\"\n",
        "    if not math.isclose(p + q, 1.0):\n",
        "        print(\"Warning: p + q should be equal to 1.\")\n",
        "\n",
        "    expansion_terms = {}\n",
        "    for k in range(n + 1):\n",
        "        # Calculate the binomial coefficient (n choose k)\n",
        "        binomial_coeff = math.comb(n, k)\n",
        "\n",
        "        # Calculate the probability of k successes\n",
        "        probability_k = binomial_coeff * (p ** k) * (q ** (n - k))\n",
        "\n",
        "        expansion_terms[k] = probability_k\n",
        "    return expansion_terms\n",
        "\n",
        "# Function to calculate and plot the z-transform with colored regions\n",
        "def plot_z_distribution_colored(num_coins_per_round, alpha=0.05):\n",
        "    \"\"\"\n",
        "    Calculates and plots the z-transform of the Binomial distribution\n",
        "    with acceptance and rejection regions highlighted.\n",
        "\n",
        "    Args:\n",
        "        num_coins_per_round: The number of coin flips (n).\n",
        "        alpha:  The significance level (proportion of the rejection region).\n",
        "                Defaults to 0.05.\n",
        "    \"\"\"\n",
        "    p = 0.5\n",
        "    n = num_coins_per_round\n",
        "\n",
        "    # Calculate binomial probabilities using scipy\n",
        "    k_values = np.arange(0, n + 1)\n",
        "    binomial_probs = binom.pmf(k_values, n, p)\n",
        "\n",
        "    # Calculate the mean and standard deviation of the binomial distribution\n",
        "    mean = n * p\n",
        "    std_dev = np.sqrt(n * p * (1 - p))\n",
        "\n",
        "    # Calculate z-scores\n",
        "    z_values = (k_values - mean) / std_dev\n",
        "\n",
        "    # Determine the rejection regions based on the cumulative distribution\n",
        "    cumulative_probs = np.cumsum(binomial_probs)\n",
        "    lower_tail_limit = alpha / 2\n",
        "    upper_tail_limit = 1 - (alpha / 2)\n",
        "\n",
        "    # Find the k values that define the boundaries of the rejection regions\n",
        "    lower_rejection_k = np.where(cumulative_probs > lower_tail_limit)[0][0] if np.where(cumulative_probs > lower_tail_limit)[0].size > 0 else 0\n",
        "    upper_rejection_k = np.where(cumulative_probs >= upper_tail_limit)[0][0] if np.where(cumulative_probs >= upper_tail_limit)[0].size > 0 else n + 1\n",
        "\n",
        "    # Prepare data for plotting\n",
        "    bar_colors = []\n",
        "    for k in k_values:\n",
        "        if k < lower_rejection_k or k >= upper_rejection_k:\n",
        "            bar_colors.append('tab:red') # Rejection region\n",
        "        else:\n",
        "            bar_colors.append('tab:blue') # Acceptance region\n",
        "\n",
        "    # Calculate the actual area of the rejection regions\n",
        "    actual_alpha = np.sum(binomial_probs[k_values < lower_rejection_k]) + np.sum(binomial_probs[k_values >= upper_rejection_k])\n",
        "\n",
        "\n",
        "    # Plot the z-distribution with colored regions\n",
        "    fig, ax = plt.subplots(figsize=(10, 6))\n",
        "    ax.bar(z_values, binomial_probs, color=bar_colors, width=z_values[1] - z_values[0] if len(z_values) > 1 else 0.8) # Adjust width for better visualization\n",
        "\n",
        "    ax.set_ylabel('Probability')\n",
        "    ax.set_xlabel('Z-score (Standardized difference from expected)')\n",
        "    ax.set_title(f'Z-transform of Binomial Distribution (n={n}, p={p}) with Rejection Regions (alpha={alpha}, actual alpha={actual_alpha:.4f})')\n",
        "    ax.grid(True)\n",
        "\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "# Example usage:\n",
        "plot_z_distribution_colored(num_coins_per_round=20, alpha=0.05)\n",
        "plot_z_distribution_colored(num_coins_per_round=10, alpha=0.05)\n",
        "plot_z_distribution_colored(num_coins_per_round=5, alpha=0.10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gdqFz7ncx9x6"
      },
      "source": [
        "> **Ejercicio.** Ejecuta el código y evalúalo.\n",
        "\n",
        ">> **Respuesta.** El código desarrollado por Gemini muestra la transformada z derivada de distribuciones binomiales simétricas. Los gráficos resultantes no son simétricos.\n",
        ">\n",
        "Añadamos a la transformada z la envolvente continua de la distribución binomial. La función resultante se conoce como la campana de Gauss estandarizada. Por lo tanto, le hicimos una solicitud a Colab:\n",
        ">\n",
        "> El código que dibuja la campana de Gauss estandarizada con regiones de rechazo con una significancia de 0,05.\n",
        "\n",
        "Colab respondió con el siguiente programa:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xWDnsKiix9x6"
      },
      "outputs": [],
      "source": [
        "# Program StandardizedGaussBellColoredTails.py\n",
        "# This program draws the standardized Gauss Bell (normal distribution)\n",
        "# with colored acceptance and rejection regions for a given significance level.\n",
        "# By Gemini\n",
        "\n",
        "# Libraries and local rename\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np # Support for scientific computing\n",
        "from scipy.stats import norm # Import the normal distribution from scipy\n",
        "\n",
        "# Function to plot the standardized Gauss Bell with colored regions\n",
        "def plot_standard_normal_colored(alpha=0.05):\n",
        "    \"\"\"\n",
        "    Plots the standardized normal distribution with acceptance and rejection regions highlighted.\n",
        "\n",
        "    Args:\n",
        "        alpha: The significance level (proportion of the rejection region).\n",
        "                Defaults to 0.05.\n",
        "    \"\"\"\n",
        "    # Generate x-values for the plot\n",
        "    x_values = np.linspace(-4, 4, 200)\n",
        "\n",
        "    # Calculate the probability density function (PDF) for the standard normal distribution\n",
        "    pdf_values = norm.pdf(x_values, 0, 1) # Mean = 0, Standard Deviation = 1\n",
        "\n",
        "    # Determine the z-scores that define the boundaries of the rejection regions\n",
        "    # Use the percent point function (inverse of CDF) to find the z-score for the given cumulative probability\n",
        "    lower_z = norm.ppf(alpha / 2)\n",
        "    upper_z = norm.ppf(1 - (alpha / 2))\n",
        "\n",
        "    # Prepare data for plotting - separate into acceptance and rejection regions\n",
        "    x_acceptance = x_values[(x_values >= lower_z) & (x_values <= upper_z)]\n",
        "    pdf_acceptance = pdf_values[(x_values >= lower_z) & (x_values <= upper_z)]\n",
        "\n",
        "    x_lower_rejection = x_values[x_values < lower_z]\n",
        "    pdf_lower_rejection = pdf_values[x_values < lower_z]\n",
        "\n",
        "    x_upper_rejection = x_values[x_values > upper_z]\n",
        "    pdf_upper_rejection = pdf_values[x_values > upper_z]\n",
        "\n",
        "\n",
        "    # Plot the standardized normal distribution with colored regions\n",
        "    fig, ax = plt.subplots(figsize=(10, 6))\n",
        "\n",
        "    # Plot the acceptance region\n",
        "    ax.fill_between(x_acceptance, pdf_acceptance, color='tab:blue', alpha=0.7, label='Acceptance Region')\n",
        "\n",
        "    # Plot the rejection regions\n",
        "    ax.fill_between(x_lower_rejection, pdf_lower_rejection, color='tab:red', alpha=0.7, label='Rejection Region')\n",
        "    ax.fill_between(x_upper_rejection, pdf_upper_rejection, color='tab:red', alpha=0.7) # No label for the second tail\n",
        "\n",
        "    ax.set_ylabel('Probability Density')\n",
        "    ax.set_xlabel('Z-score')\n",
        "    ax.set_title(f'Standardized Normal Distribution with Rejection Regions (alpha={alpha})')\n",
        "    ax.grid(True)\n",
        "    ax.legend()\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "# Example usage:\n",
        "plot_standard_normal_colored(alpha=0.05)\n",
        "plot_standard_normal_colored(alpha=0.01)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pAWUyOASx9x6"
      },
      "source": [
        "> **Ejercicio.** Ejecuta el código y evalúalo.\n",
        "\n",
        ">> **Respuesta.** El código es asombroso. Muestra la potencia de Python, que simplifica las cosas, junto con un razonamiento matemático transparente. La ventaja de este código es su extrema generalidad. Presenta dos ejemplos. El primero tiene una significancia de 0,05, y la región de rechazo derecha comienza un poco antes de 2. Esto está de acuerdo con la literatura: el valor z es 1,96. Por lo tanto, consideramos que el código es correcto. El código aproxima todas las distribuciones binomiales simétricas que, tras la transformada z, están envueltas por esta campana de Gauss. Lo que necesitamos saber es cómo pasar de una distribución binomial a este gráfico. Esto se hace calculando la media y la desviación estándar. Si la distribución binomial está definida por $n$ monedas y con la probabilidad de cara igual a $p = 0,5$, el número medio de caras es $\\mu = np = n/2$ y la desviación estándar es $\\sigma = \\sqrt{np(1-p)} = \\sqrt{n/4}$. Con esto, la transformada z se convierte en:\n",
        "\n",
        ">>>$z(x) = \\frac{x-\\mu}{\\sigma} = \\frac{x-n/2}{\\sqrt{n/4}} = \\frac{x-n/2}{\\sqrt{n}/2} = \\frac{2x-n}{\\sqrt{n}}$\n",
        ">>>\n",
        ">> Por ejemplo, si tenemos 20 monedas y un número de caras $x = 12$, el valor z se convierte en: $z(12) = \\frac{2(12) - 20}{\\sqrt{20}} = \\frac{4}{4.5} = 0.9 \\sim 1$\n",
        ">>>\n",
        ">> Esto significa que 12 está 1 desviación estándar hacia arriba de la media, que es 10. ¿Es cierto? Veamos:\n",
        ">>\n",
        ">> La desviación estándar es:\n",
        ">>\n",
        ">>> $\\sigma = \\sqrt{npq} = \\sqrt{np(1-p)} = \\sqrt{n/4} = \\sqrt{20/4} = \\sqrt{5} = 2.2   $\n",
        ">>\n",
        ">> Dado que la media es $10$, la media más 1 desviación estándar es $10 + 2.2 = 12.2 \\sim 12$, como se desea.\n",
        "\n",
        "> **Ejercicio** Superponer una campana de Gauss estándar sobre la envolvente de una distribución binomial estandarizada para comprobar el ajuste.\n",
        "\n",
        ">> **Respuesta.** Necesitamos dibujar dos funciones en el mismo gráfico. Por lo tanto, buscamos en Google:\n",
        ">>\n",
        ">>> Cómo dibujar dos funciones en Python\n",
        ">>\n",
        "> Gemini respondió con un procedimiento explicado, del cual extrajimos el siguiente código:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "q4q0AJ2ex9x6"
      },
      "outputs": [],
      "source": [
        "# Program DrawTwoFunctions.py\n",
        "# By Gemini\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Functions are defined\n",
        "def func1(x):\n",
        "    return np.sin(x)\n",
        "\n",
        "def func2(x):\n",
        "    return np.cos(x)\n",
        "\n",
        "# 400 points along the x-axis are chosen\n",
        "x_values = np.linspace(0, 2 * np.pi, 400) # From 0 to 2pi, with 400 points\n",
        "# The y-values f the two functions are calculated\n",
        "y_values_func1 = func1(x_values)\n",
        "y_values_func2 = func2(x_values)\n",
        "# The two functions are drawn\n",
        "plt.plot(x_values, y_values_func1, label='sin(x)', color='blue', linestyle='-')\n",
        "plt.plot(x_values, y_values_func2, label='cos(x)', color='red', linestyle='--')\n",
        "plt.xlabel('X-axis')\n",
        "plt.ylabel('Y-axis')\n",
        "plt.title('Plot of Two Functions')\n",
        "plt.legend() # Displays the labels defined in plt.plot()\n",
        "\n",
        "# Display the Plot.\n",
        "\n",
        "plt.grid(True) # Optional: adds a grid\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JuikB3Vdx9x6"
      },
      "source": [
        "La lección es: para dibujar dos funciones en el mismo gráfico, se construyen valores de x, y se utilizan para los dos conjuntos de valores de y. Cada función se dibuja por separado. Para implementar esto, reutilizamos los programas `zDistribution.py`, que muestra la envolvente de una distribución binomial estandarizada, y `StandardizedGaussBellColoredTails.py`, que representa la campana estándar. Encontramos un problema: los valores de x se eligen de forma diferente para cada función. Probamos el siguiente código:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NbO4ryWJx9x7"
      },
      "outputs": [],
      "source": [
        "# Program standardBellFitsBinomialDistribution.py\n",
        "# The Binomial Distribution is estimated by a simulation and drawn,\n",
        "# it is then standardized to produce an estimation of\n",
        "# the z-distribution.\n",
        "# A Standard Gauss Bell is superposed to check the fitting.\n",
        "\n",
        "\n",
        "# Libraries\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "import statistics\n",
        "from scipy.stats import norm # Import the normal distribution from scipy\n",
        "\n",
        "# Function to plot the standardized Gauss Bell\n",
        "def values_standard_normal():\n",
        "    \"\"\"\n",
        "    Plots the standardized normal distribution with acceptance and rejection regions highlighted.\n",
        "\n",
        "    Args:\n",
        "        alpha: The significance level (proportion of the rejection region).\n",
        "                Defaults to 0.05.\n",
        "    \"\"\"\n",
        "    # Generate x-values for the plot\n",
        "    x_values = np.linspace(-4, 4, 200)\n",
        "\n",
        "    # Calculate the probability density function (PDF) for the standard normal distribution\n",
        "    pdf_values = norm.pdf(x_values, 0, 1) # Mean = 0, Standard Deviation = 1\n",
        "\n",
        "    return x_values, pdf_values\n",
        "\n",
        "\n",
        "# Parameters for the simulation of the Binomial\n",
        "num_coins_per_round = 20\n",
        "num_repetitions = 10000\n",
        "\n",
        "# Simulate coin flips\n",
        "results = []\n",
        "for _ in range(num_repetitions):\n",
        "    heads_in_round = 0\n",
        "    for _ in range(num_coins_per_round):\n",
        "        # 0 for tails, 1 for heads\n",
        "        if random.choice([0, 1]) == 1:\n",
        "            heads_in_round += 1\n",
        "    results.append(heads_in_round)\n",
        "\n",
        "# Calculate statistics\n",
        "total_heads = 0\n",
        "for x in results:\n",
        "    total_heads += x\n",
        "proportion_heads = total_heads / (num_coins_per_round * num_repetitions)\n",
        "heads_distribution = Counter(results)\n",
        "\n",
        "\n",
        "# Arrays to keep values to be graphed\n",
        "x_values = []\n",
        "y_values = []\n",
        "\n",
        "\n",
        "\n",
        "# Print the results\n",
        "print(\"Heads corresponds with 1 in a random choice between 0, 1 \")\n",
        "print(f\"Simulation of {num_repetitions} rounds \")\n",
        "print(f\"with {num_coins_per_round} coins per round:\")\n",
        "print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "print(\"\\nDistribution of heads per round:\")\n",
        "# Sort the distribution for better readability\n",
        "sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    x_values.append(num_heads)\n",
        "    y_values.append(count)\n",
        "    print(f\"  {num_heads} heads: {count} times\")\n",
        "\n",
        "# Plot the function\n",
        "plt.plot(x_values, y_values, label=\"Heads_distribution\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"Number of heads\")\n",
        "plt.ylabel(\"Count\")\n",
        "plt.title(\"Graph of a heads distribution\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "# Standarization\n",
        "\n",
        "# Values for the z-distribution, z_values and estimated probability\n",
        "z_values = []\n",
        "p_values = []\n",
        "\n",
        "# The mean number of heads is computed\n",
        "mean = statistics.mean(results)\n",
        "mean2 = 0.5*num_coins_per_round\n",
        "print(f\"Observed mean = {mean}, expected {mean2}\")\n",
        "#The standard deviation of results is computed\n",
        "std_dev = statistics.stdev(results)\n",
        "std_dev_expected = np.sqrt(mean2*0.5) #sqrt(npq)\n",
        "print(f\"Observed Standard Deviation: {std_dev:.4f}, Expected: {std_dev_expected:.4f}\")\n",
        "\n",
        "# The z-distribution\n",
        "# z-transform to measure the difference between observed and expected\n",
        "# Observed = num_heads\n",
        "# Expected = mean2 = np = 20 * 0.5 = 10\n",
        "total_frequency = 0\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    z = (num_heads - mean2) / std_dev # Calculate z-score using the observed mean\n",
        "    z_values.append(z)\n",
        "    p = count/num_repetitions\n",
        "    p_values.append(p)\n",
        "    total_frequency += p\n",
        "    print(f\"  {z:.4f} z_value: {p:.4f} probability\")\n",
        "\n",
        "\n",
        "print(f\"Total frequency= {total_frequency}, expected = 1\")\n",
        "\n",
        "# Plot the estimated z-distribution\n",
        "plt.plot(z_values, p_values, label=\"Estimated z-distribution\")\n",
        "\n",
        "x_Bell, y_Bell = values_standard_normal()\n",
        "# Plot the Gauss Bell\n",
        "plt.plot(x_Bell, y_Bell, label=\"Standard Gauss Bell\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"z_values\")\n",
        "plt.ylabel(\"Probability\")\n",
        "plt.title(\"Standard Gauss Bell fits the Binomial\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6WF0Q2cbx9x7"
      },
      "source": [
        ">>No hubo problema con los diferentes valores de x para cada función. Por otro lado, ambas funciones resultantes tienen forma de campana, pero sus alturas difieren. ¿Por qué? Solo vemos una causa: los procedimientos de normalización. De hecho, la campana de Gauss está, por naturaleza, normalizada para representar una función de densidad de probabilidad, normalizada por área, cuya integral es 1. Pero nuestra estimación de la binomial a partir de una simulación se ha normalizado por la altura de las barras, cuya longitud total debe ser 1. Para comprobar esta hipótesis, tenemos una predicción: debe haber una constante que actúe como factor de estiramiento que haga que ambas gráficas sean casi iguales. La constante relaciona las alturas de ambas funciones en sus máximos. El código es el siguiente:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EO0hnnfAx9x7"
      },
      "outputs": [],
      "source": [
        "# Program standardBellFitsBinomialDistribution.py\n",
        "# The Binomial Distribution is estimated by a simulation and drawn,\n",
        "# it is then standardized to produce an estimation of\n",
        "# the z-distribution.\n",
        "# A Standard Gauss Bell is superposed to check the fitting.\n",
        "\n",
        "\n",
        "# Libraries\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "import statistics\n",
        "from scipy.stats import norm # Import the normal distribution from scipy\n",
        "\n",
        "\n",
        "##########\n",
        "\n",
        "# Function to plot the standardized Gauss Bell with colored regions\n",
        "def values_standard_normal():\n",
        "    \"\"\"\n",
        "    Plots the standardized normal distribution with acceptance and rejection regions highlighted.\n",
        "\n",
        "    Args:\n",
        "        alpha: The significance level (proportion of the rejection region).\n",
        "                Defaults to 0.05.\n",
        "    \"\"\"\n",
        "    # Generate x-values for the plot\n",
        "    x_values = np.linspace(-4, 4, 400)\n",
        "\n",
        "    # Calculate the probability density function (PDF) for the standard normal distribution\n",
        "    pdf_values = norm.pdf(x_values, 0, 1) # Mean = 0, Standard Deviation = 1\n",
        "\n",
        "    return x_values, pdf_values\n",
        "\n",
        "#########\n",
        "\n",
        "# Parameters for the simulation of the Binomial\n",
        "num_coins_per_round = 20\n",
        "num_repetitions = 10000\n",
        "\n",
        "# Simulate coin flips and count heads\n",
        "results = []\n",
        "for _ in range(num_repetitions):\n",
        "    heads_in_round = 0\n",
        "    for _ in range(num_coins_per_round):\n",
        "        # 0 for tails, 1 for heads\n",
        "        if random.choice([0, 1]) == 1:\n",
        "            heads_in_round += 1\n",
        "    results.append(heads_in_round)\n",
        "\n",
        "# Calculate statistics\n",
        "total_heads = 0\n",
        "for x in results:\n",
        "    total_heads += x\n",
        "total_number_coins = num_coins_per_round * num_repetitions\n",
        "proportion_heads = total_heads / (total_number_coins)\n",
        "heads_distribution = Counter(results)\n",
        "\n",
        "\n",
        "#Arrays to keep values to be graphed\n",
        "x_values = []\n",
        "y_values = []\n",
        "\n",
        "# Print results\n",
        "print(\"Heads corresponds with 1 in a random choice between 0, 1 \")\n",
        "print(f\"Simulation of {num_repetitions} rounds \")\n",
        "print(f\"with {num_coins_per_round} coins per round:\")\n",
        "print(f\"\\nTotal number of heads across all repetitions: {total_heads}\")\n",
        "print(f\"Proportion of heads across all repetitions: {proportion_heads:.4f}\")\n",
        "print(\"\\nDistribution of heads per round:\")\n",
        "\n",
        "# Sort the distribution according to human needs\n",
        "sorted_distribution = dict(sorted(heads_distribution.items()))\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    x_values.append(num_heads)\n",
        "    y_values.append(count)\n",
        "    print(f\"  {num_heads} heads: {count} times\")\n",
        "\n",
        "# Normalization of y_values\n",
        "\n",
        "# y_values = [y / total_number_coins for y in y_values]\n",
        "y_values = [y / num_repetitions for y in y_values]\n",
        "# Plot the function\n",
        "plt.plot(x_values, y_values, label=\"Heads_distribution\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"Number of heads\")\n",
        "plt.ylabel(\"Count\")\n",
        "plt.title(\"Graph of a heads distribution\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "# Standarization\n",
        "\n",
        "# values for the z-distribution, z_values and estimated probability\n",
        "z_values = []\n",
        "p_values = []\n",
        "\n",
        "# the mean number of heads is computed\n",
        "mean = statistics.mean(results)\n",
        "mean2 = 0.5*num_coins_per_round\n",
        "print(f\"Observed mean = {mean}, expected {mean2}\")\n",
        "# The standard deviation of results is computed\n",
        "std_dev = statistics.stdev(results)\n",
        "std_dev_expected = np.sqrt(mean2*0.5) #sqrt(npq)\n",
        "print(f\"Observed Standard Deviation: {std_dev:.4f}, Expected: {std_dev_expected:.4f}\")\n",
        "\n",
        "# The z-distribution\n",
        "# z-transform to measure the difference between observed and expected\n",
        "# Observed = num_heads\n",
        "# Expected = mean2 = np = 20 * 0.5 = 10\n",
        "total_frequency = 0\n",
        "for num_heads, count in sorted_distribution.items():\n",
        "    z = (num_heads - mean2) / std_dev # Calculate z-score using the observed mean\n",
        "    z_values.append(z)\n",
        "    p = count/num_repetitions\n",
        "    p_values.append(p)\n",
        "    total_frequency += p\n",
        "    print(f\"  {z:.4f} z_value: {p:.4f} relative frequency\")\n",
        "\n",
        "\n",
        "print(f\"Total frequency= {total_frequency}, expected = 1\")\n",
        "\n",
        "# values of the Standard Bell\n",
        "x_Bell, y_Bell = values_standard_normal()\n",
        "print(\"y_values of the bell \" , y_Bell)\n",
        "\n",
        "# Reescaling\n",
        "bell_0 = y_Bell[200] #max value of the bell with 200 points\n",
        "print(f\"bell_0 = {bell_0}\")\n",
        "print(\"p_values : \" , p_values)\n",
        "\n",
        "# Maximal value of the Binomial\n",
        "max = -1\n",
        "for i in range(len(p_values)):\n",
        "    if p_values[i] > max:\n",
        "        max = p_values[i]\n",
        "\n",
        "print(f\"max = {max}\")\n",
        "\n",
        "# Rescaling to adjust maxima\n",
        "k = bell_0/max\n",
        "print(f\"Streching factor, k = {k}\")\n",
        "for i in range(len(p_values)):\n",
        "    p_values[i] = p_values[i]*k\n",
        "\n",
        "\n",
        "# Plot the estimated z-distribution\n",
        "plt.plot(z_values, p_values, label=\"Estimated z-distribution\")\n",
        "\n",
        "\n",
        "# Plot the Gauss Bell\n",
        "plt.plot(x_Bell, y_Bell, label=\"Standard Gauss Bell\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"z_values\")\n",
        "plt.ylabel(\"Probability\")\n",
        "plt.title(\"Standard Gauss Bell fits the Standardized Binomial\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2oQwakt-x9x8"
      },
      "source": [
        ">> Tras ajustar la distribución binomial mediante una constante adecuada, observamos que las gráficas de ambas funciones coinciden. Este resultado respalda nuestra creencia de que los diferentes modos de normalización causan diferentes alturas máximas para cada función.\n",
        "\n",
        "Probemos ahora nuestros procedimientos con otra configuración.\n",
        "\n",
        "> **Ejercicio.** Superponga una campana de Gauss estándar sobre el diagrama de barras de una distribución binomial para comprobar el ajuste.\n",
        "\n",
        ">> **Respuesta.** La media de la distribución binomial es $np$ y la desviación es $\\sqrt{np(1-p)}$. Cuando $p = 0,5$, estos valores se convierten en $n/2$ y $\\sqrt{n}/2$ respectivamente. El código del gráfico de barras de la distribución binomial se adaptó del `Program binomialDistriColoredTails.py` y el de la campana, de `binomialDistriColoredTails.py`. El procedimiento es una variación del código de la respuesta del ejercicio anterior. El código es el siguiente:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zwlwIWmZx9x8"
      },
      "outputs": [],
      "source": [
        "# Program  GaussBellFitsBinomialDistribution.py\n",
        "# The Binomial Distribution comes from the Newton Binomial.\n",
        "# A Gauss Bell is superposed to check the fitting.\n",
        "\n",
        "\n",
        "# Libraries\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "import statistics\n",
        "from scipy.stats import norm # Import the normal distribution from scipy\n",
        "\n",
        "###### THE GAUSSIAN BELL ######\n",
        "\n",
        "# Function to plot a  Gauss Bell with mean m and standard deviation s\n",
        "# in the range from -1 to n+1, where\n",
        "# n is the number of coins of a Binomial Distribution.\n",
        "def values_normal_distribution(m,s, n):\n",
        "    \"\"\"\n",
        "    Plots the standardized normal distribution with acceptance and rejection regions highlighted.\n",
        "\n",
        "    Args:\n",
        "        alpha: The significance level (proportion of the rejection region).\n",
        "                Defaults to 0.05.\n",
        "    \"\"\"\n",
        "    # Generate x-values for the plot between 0 and n\n",
        "    x_values = np.linspace(0, n, 400) #400 points\n",
        "\n",
        "    # Calculate the probability density function (PDF) for the standard normal distribution\n",
        "    pdf_values = norm.pdf(x_values, m, s) # Mean = m, Standard Deviation = s\n",
        "\n",
        "    return x_values, pdf_values\n",
        "\n",
        "######## THE BINOMIAL DISTRIBUTION #######\n",
        "\n",
        "# The binomial expansion\n",
        "def binomial_expansion(p, q, n):\n",
        "    \"\"\"\n",
        "    Calculates the terms of the binomial expansion (p+q)^n.\n",
        "\n",
        "    Args:\n",
        "    p: The probability of the first outcome.\n",
        "    q: The probability of the second outcome (q = 1 - p).\n",
        "    n: The number of trials.\n",
        "\n",
        "    Returns:\n",
        "    A dictionary where keys are the number of successes (k)\n",
        "    and values are the corresponding probabilities.\n",
        "    \"\"\"\n",
        "    if not math.isclose(p + q, 1.0):\n",
        "        print(\"Warning: p + q should be equal to 1.\")\n",
        "\n",
        "    expansion_terms = {}\n",
        "    for k in range(n + 1):\n",
        "        # Calculate the binomial coefficient (n choose k)\n",
        "        binomial_coeff = math.comb(n, k)\n",
        "\n",
        "    # Calculate the probability of k successes\n",
        "    probability_k = binomial_coeff * (p ** k) * (q ** (n - k))\n",
        "\n",
        "    expansion_terms[k] = probability_k\n",
        "    return expansion_terms\n",
        "\n",
        "\n",
        "# Binomial Expansion for a fair coin (p=0.5, q=0.5)\n",
        "# This gives the Mathematically Expected Binomial Distribution\n",
        "p = 0.5\n",
        "q = 0.5\n",
        "n = num_coins_per_round = 20\n",
        "binomial_probs = binomial_expansion(p, q, n)\n",
        "cumulate_prob = 0.0\n",
        "print(f\"Binomial expansion for (0.5 + 0.5)^{n}:\")\n",
        "for k, prob in binomial_probs.items():\n",
        "    cumulate_prob += prob\n",
        "    print(f\"  {k} heads: {prob:.4f}     cumulate_prob: {cumulate_prob} \")\n",
        "\n",
        "#######  The bar diagram of the Binomial\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "\n",
        "k_class = [] # Horizontal label\n",
        "p_values = [] # vertical values\n",
        "bar_labels = [] # colors of bars\n",
        "bar_colors = []\n",
        "\n",
        "for k, prob in binomial_probs.items():\n",
        "    k_class.append(k)\n",
        "    p_values.append(prob)\n",
        "\n",
        "ax.bar(k_class, p_values)\n",
        "ax.set_ylabel('probability')\n",
        "ax.set_title('Binomial Distribution')\n",
        "\n",
        "\n",
        "############## THE BELL FITS A BINOMIAL ######\n",
        "\n",
        "n = 20 # number of coins\n",
        "p = 0.5 #probability of heads\n",
        "q = 1 - p\n",
        "m = n*p # mean\n",
        "s = math.sqrt(n*p*q) # standard deviation\n",
        "print(f\"Mean = {m}, Standard Deviation = {s}\")\n",
        "\n",
        "# values of the Standard Bell\n",
        "x_Bell, y_Bell = values_normal_distribution(m,s, n)\n",
        "\n",
        "\n",
        "# Reescaling\n",
        "\n",
        "print(\"y_values of the bell \", y_Bell)\n",
        "\n",
        "# max value of the bell\n",
        "bell_0 = y_Bell[200] #max value of the bell with 400 points\n",
        "print(f\"max value f the bell = bell_0 = {bell_0}\")\n",
        "\n",
        "# Maximal value of the Binomial\n",
        "max = -1\n",
        "for i in range(len(p_values)):\n",
        "    if p_values[i] > max:\n",
        "        max = p_values[i]\n",
        "print(f\"max value of the binomial = {max}\")\n",
        "\n",
        "#Rescaling to adjust maxima\n",
        "k = bell_0/max\n",
        "print(f\"Streching factor, k = {k}\")\n",
        "for i in range(len(p_values)):\n",
        "    p_values[i] = p_values[i]*k\n",
        "\n",
        "\n",
        "# Envelope of the Binomial\n",
        "plt.plot(k_class, p_values, label=\"Binomial Distribution\")\n",
        "\n",
        "# Plot the Gauss Bell\n",
        "plt.plot(x_Bell, y_Bell, label=\"Standard Gauss Bell\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"z_values\")\n",
        "plt.ylabel(\"Probability\")\n",
        "plt.title(\"Standard Gauss Bell fits the Binomial Distribution\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ESQSO3-vx9x8"
      },
      "source": [
        "## Interpretación\n",
        "\n",
        "Para comparar la gráfica de la campana de Gauss continua con el diagrama de barras de la distribución binomial, debemos considerar el modo de normalización. En la campana, la normalización se basa en las áreas, mientras que en la binomial, en las longitudes de las barras. Este problema es prácticamente irrelevante para la distribución binomial no normalizada, ya que cada barra puede interpretarse como un área dada por su altura multiplicada por su ancho, es decir, 1. Si aceptamos esto, concluimos que la campana de Gauss y la distribución binomial coinciden.\n",
        "\n",
        "Nuestro resultado es: la campana de Gauss es la envolvente de la distribución binomial, donde ambas distribuciones tienen la misma media, $np$, y desviaciones estándar, $\\sqrt{np(1-p)}$.\n",
        "\n",
        "Esta coincidencia nos permite proponer una explicación del siguiente hecho: la campana de Gauss, o una buena aproximación a ella, se observa en las más diversas situaciones de la naturaleza, la tecnología y la sociedad. ¿Por qué? Porque la distribución normal o campana de Gauss surge del modo de funcionamiento conjunto de muchos factores independientes, cada uno de poca importancia, pero que juntos desempeñan un papel decisivo. Y la contribución de cada factor es caótica. A veces puede ignorarse, pero otras no. Este comportamiento puede modelarse como el resultado aleatorio de una moneda al lanzarla, ya sea cara o cruz.\n",
        "\n",
        "# DISCRIMINACIÓN ENTRE DOS TEORÍAS\n",
        "\n",
        "Si recopilamos suficientes datos aleatorios, podemos decidir entre teorías rivales. Ilustremos esto con un caso práctico concreto.\n",
        "\n",
        "Hemos demostrado que 14 caras de 20 pueden explicarse por dos teorías: $p = 0.5$ y $p = 2/3$. Esto significa que un solo dato es insuficiente para decidir entre las dos teorías. Inferimos que pocos datos también son insuficientes, pero si el tamaño de los datos aumenta, posiblemente surgirá una tendencia que debemos aprovechar para discriminar las dos teorías. Diseñemos una simulación para demostrar que la recopilación de suficientes datos permite rechazar una de estas hipótesis nulas. ¿Cómo lo haremos?\n",
        "\n",
        "Analicemos el siguiente escenario: Tendremos dos simulaciones. En la primera, lanzamos monedas cuyas caras y cruces tienen la misma probabilidad de salir para estimar la distribución de caras. Esto ya se ha hecho. En el segundo, lanzaremos monedas cuya cara tenga una probabilidad de 2/3 para generar nuestros \"datos observados\", de los cuales tomaremos conjuntos de n datos y calcularemos la media. Nuestra pregunta es: ¿Podemos usar la distribución encontrada en el paso uno para clasificar la media encontrada en el segundo paso? ¡La respuesta es NO! Esto se debe a que la distribución y los datos observados se refieren a objetos diferentes. La distribución se refiere a datos aislados, mientras que los datos observados se refieren a medias de n datos. ¿Qué debemos corregir?\n",
        "\n",
        "Nuestro nuevo escenario es el siguiente: fijamos $n$ como el número de datos observados, a partir del cual calcularemos la media que debe clasificarse como ordinaria o extraña. Por lo tanto, tendremos dos simulaciones. En la primera, lanzamos monedas cuyas caras tienen la misma probabilidad, $p = 0.5$. Lanzaremos $n$ monedas, tomaremos la media y estimaremos la distribución de estas medias. En la segunda, aplicaremos la teoría rival. Lanzaremos monedas cuya cara tenga una probabilidad $p = 2/3$ para generar nuestros \"datos observados\", de los cuales tomaremos una muestra aleatoria de $n$ datos y calcularemos la media. Nuestra pregunta es: ¿podemos usar la distribución encontrada en el paso uno para clasificar la media encontrada en el segundo paso como ordinaria o extraña? ¡La respuesta es SÍ! Esto se debe a que tanto la distribución como la media observada tienen el mismo tipo o naturaleza y ambas se refieren a medias de muestras del mismo tamaño. En la literatura, la distribución encontrada en el paso uno se denomina *media muestral con $n$ datos*. Debemos indagar sobre el valor de $n$. Solo sabemos que si n es bajo, no podremos rechazar la teoría rival.\n",
        "\n",
        "Pasemos a las simulaciones.\n",
        "\n",
        "> **Ejemplo.** Hallemos la distribución de la media muestral para 20 monedas y p = 0,5. El código es el siguiente. Reutilizamos el programa `coinsProbOfHeadsTwoThirds.py`.\n",
        ">\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-O5RDlg5x9x9"
      },
      "outputs": [],
      "source": [
        "# Program sampleMeanDistribution.py\n",
        "# We estimate the distribution of\n",
        "# sample means of samples of size n\n",
        "# generated according to the first theory, p = 0.5.\n",
        "\n",
        "\n",
        "# Libraries and local rename\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "import statistics\n",
        "\n",
        "\n",
        "# 1. Parameters for the simulation\n",
        "num_coins_per_round = 20\n",
        "n = 200 # Size of each sample\n",
        "num_repetitions = 10000\n",
        "\n",
        "\n",
        "# Simulate coin flips\n",
        "sample_means = []\n",
        "for i in range(num_repetitions):\n",
        "    heads_in_round = []\n",
        "\n",
        "    for j in range(n):\n",
        "        heads = 0\n",
        "        for _ in range(num_coins_per_round):\n",
        "            # 0 for tails, 1 for heads\n",
        "            if random.choice([0, 1]) == 1:\n",
        "                heads += 1\n",
        "        heads_in_round.append(heads)\n",
        "    sample_means.append(statistics.mean(heads_in_round))\n",
        "\n",
        "# Calculate distribution\n",
        "sample_means_distribution = Counter(sample_means)\n",
        "\n",
        "# Arrays to keep values to be graphed\n",
        "x_values = []\n",
        "y_values = []\n",
        "\n",
        "# Print the results\n",
        "print(\"Heads is 1 in a random choice among 0, 1\")\n",
        "print(\"So, the probability of heads is 0.5\")\n",
        "print(\"and that of tails is 0.5\")\n",
        "print(f\"with {num_coins_per_round} coins per round:\")\n",
        "print(f\"sample_mean of samples of size {n} rounds\")\n",
        "print(f\"Simulation of {num_repetitions} repetitions \")\n",
        "\n",
        "print(\"\\nDistribution of sample_means:\")\n",
        "# Sort the distribution for better readability\n",
        "sorted_distribution = dict(sorted(sample_means_distribution.items()))\n",
        "for sample_mean, count in sorted_distribution.items():\n",
        "    x_values.append(sample_mean)\n",
        "    y_values.append(count)\n",
        "    print(f\"  {sample_mean} heads: {count} times\")\n",
        "\n",
        "# Plot the function\n",
        "plt.plot(x_values, y_values, label=\"Sample_means_distribution\")\n",
        "\n",
        "# Add labels, title, and legend\n",
        "plt.xlabel(\"Sample_mean\")\n",
        "plt.ylabel(\"Count\")\n",
        "plt.title(\"Graph of sample means distribution\")\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "\n",
        "# Display the plot\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_85Q-fqIx9x9"
      },
      "source": [
        "**Ejercicio**. Ejecute el código anterior y determine la media y el rango de la distribución.\n",
        "\n",
        "**Respuesta.** Con una probabilidad de cara de 0,5, muestras de 200 y 10 000 repeticiones, la media de la distribución de medias muestrales es 10, como se esperaba, y el rango de la distribución va de 9.46 to 10.5.  \n",
        "\n",
        "**Ejercicio**. Estime la media y el rango de la distribución de la media muestral con una probabilidad de cara de 2/3.\n",
        "\n",
        "**Respuesta.** El programa anterior se volvió a ejecutar con una pequeña modificación, estableciendo la probabilidad de cara en 2/3. La modificación se incluyó en la línea de código `if random.choice([0, 1, 1]) == 1:`. La media de la distribución del número medio de caras en muestras de tamaño 200 es de aproximadamente 13,3, como se esperaba. El rango de la distribución va de 12,71 a 13,91.\n",
        "\n",
        "Nuestro ejemplo y ejercicio nos permiten afirmar que, cuando el tamaño de la muestra es de 200, los rangos observados de las distribuciones correspondientes a las dos teorías diferentes, p = 0,5 y p = 2/3 = 0,66, no se superponen. En consecuencia, las predicciones de cada teoría se vuelven extrañas para la otra. Esto significa que un tamaño de muestra de 200 es suficiente para discriminar entre las dos teorías.\n",
        "\n",
        "> **Ejercicio**. Ejecute el programa anterior para valores crecientes del tamaño de la muestra y observe qué sucede con el rango de la distribución observada.\n",
        ">>\n",
        ">> **Respuesta.** Para una muestra de 50, el rango observado va de 8,8 a 11,12. Para una muestra de 100, el rango observado va de 9,22 a 10,81.\n",
        "Para una muestra de 200, el rango observado va de 9,46 a 10,5.\n",
        "Para una muestra de 500, el rango observado va de 9,64 a 10,37.\n",
        ">>\n",
        ">> Observamos que, cuando el tamaño de la muestra aumenta, la distribución observada tiende a contraerse y se concentra en torno a la media esperada.\n",
        "\n",
        "> **Desafío**. Resuelva, si puede, el siguiente misterio creado por dos observaciones contradictorias.\n",
        ">> - Primero: Nuestras simulaciones indican claramente que, cuando el tamaño de la muestra aumenta, la distribución observada tiende a contraerse y se concentra en torno a la media esperada. A partir de aquí, formulamos una predicción: para una cantidad infinita de datos, la distribución observada de las medias muestrales tiene un rango de 0 y cada media muestral coincide con la media esperada. O bien, la media muestral converge a la media esperada cuando el tamaño de la muestra se vuelve infinito.\n",
        ">> - Segundo: El número de caras en una distribución binomial con 2 monedas toma los valores 0, 1 y 2. Y para 7 monedas, ese número va de 0 a 7. En general, para $n$ monedas, el rango de la distribución va de 0 a $n$. En resumen: el rango crece con $n$. Por lo tanto, la media muestral tiene más margen de maniobra cuanto mayor sea $n$. Por lo tanto, las campanas de las medias muestrales no pueden concentrarse cuanto mayor sea $n$. La convergencia, si la hay, es dudosa.\n",
        "\n",
        "Para reforzar nuestros conocimientos, debemos aplicar el formalismo oficial a la discusión anterior. Pero antes, hagamos algo para mejorar la comprensión de nuestro programa.\n",
        "\n",
        "> **Ejercicio**. Encapsule el programa anterior para que sea fácil de invocar y comprender.\n",
        ">>\n",
        ">> **Respuesta.** El siguiente programa encapsula dos procedimientos básicos del programa anterior. Para probarlo, dibujamos de nuevo las dos distribuciones de medias muestrales con las que trabajamos."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zKpW6bPEx9x9"
      },
      "outputs": [],
      "source": [
        "# Program twoSampleMeanDistributions.py\n",
        "# 1.We estimate the distribution of\n",
        "# sample means of n data\n",
        "# generated according to the first theory, p = 0.5.\n",
        "# 2. We estimate the distribution of\n",
        "# sample means of n data\n",
        "# generated according to the second theory, p = 2/3.\n",
        "\n",
        "\n",
        "# Libraries and local rename\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "import statistics\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# 1. Parameters for the simulation\n",
        "num_coins_per_round = 20\n",
        "n = 200 # Size of each sample\n",
        "num_repetitions = 1000\n",
        "\n",
        "\n",
        "def sample_mean_distribution(sample_size, p):\n",
        "    # Simulate coin flips\n",
        "    sample_means = []\n",
        "    for i in range(num_repetitions):\n",
        "        heads_in_round = []\n",
        "        for j in range(sample_size):\n",
        "            heads = 0\n",
        "            for _ in range(num_coins_per_round):\n",
        "                # 0 for tails, 1 for heads\n",
        "                if p == 0.5:\n",
        "                    # Probability of heads =  0.5\n",
        "                    if random.choice([0, 1]) == 1:\n",
        "                        heads += 1\n",
        "                if p == 0.66:\n",
        "                    # Probability of heads = 2/3 = 0.66\n",
        "                    if random.choice([0, 1, 1]) == 1:\n",
        "                        heads += 1\n",
        "            heads_in_round.append(heads)\n",
        "        sample_means.append(statistics.mean(heads_in_round))\n",
        "\n",
        "    # Calculate distribution\n",
        "    sample_means_distribution = Counter(sample_means)\n",
        "    return sample_means_distribution\n",
        "\n",
        "\n",
        "\n",
        "def graph_sample_mean_distribution(sample_means_distribution, n, p):\n",
        "    # Arrays to keep values to be graphed\n",
        "    x_values = []\n",
        "    y_values = []\n",
        "\n",
        "    # Print the results\n",
        "    print(\"Heads is 1 in a random choice among 0, 1\")\n",
        "    print(\"So, the probability of heads is 0.5\")\n",
        "    print(\"and that of tails is 0.5\")\n",
        "    print(f\"with {num_coins_per_round} coins per round:\")\n",
        "    print(f\"sample_mean of samples of size {n} rounds\")\n",
        "    print(f\"Simulation of {num_repetitions} repetitions \")\n",
        "\n",
        "    print(\"\\nDistribution of sample_means:\")\n",
        "    # Sort the distribution for better readability\n",
        "    sorted_distribution = dict(sorted(sample_means_distribution.items()))\n",
        "    for sample_mean, count in sorted_distribution.items():\n",
        "        x_values.append(sample_mean)\n",
        "        y_values.append(count)\n",
        "        print(f\"  {sample_mean} heads: {count} times\")\n",
        "\n",
        "    # Plot the function\n",
        "    plt.plot(x_values, y_values, label=\"Sample_means_distribution\")\n",
        "\n",
        "    # Add labels, title, and legend\n",
        "    plt.xlabel(\"Sample_mean\")\n",
        "    plt.ylabel(\"Count\")\n",
        "    plt.title(f\"Graph of sample means distribution, sample_size = {n}, p = {p}\")\n",
        "    plt.grid(True)\n",
        "    plt.legend()\n",
        "\n",
        "    # Display the plot\n",
        "    plt.show()\n",
        "\n",
        "def main():\n",
        "    # Probability of heads,\n",
        "    # only two possible values: 0.5 and 0.66\n",
        "    p = 0.5\n",
        "    # n is the size of the sample.\n",
        "    sample_means_distribution = sample_mean_distribution(n, p)\n",
        "    graph_sample_mean_distribution(sample_means_distribution, n, p)\n",
        "    p = 0.66\n",
        "    sample_means_distribution = sample_mean_distribution(n, p)\n",
        "    graph_sample_mean_distribution(sample_means_distribution, n, p)\n",
        "\n",
        "\n",
        "main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UeBBNjl9x9x9"
      },
      "source": [
        "**Ejercicio**. Discrimine entre las dos teorías, p = 0,5 y p = 2/3 = 0,66, demostrando que, si el tamaño de la muestra es suficientemente grande, un dato, obtenido según las predicciones de una teoría, es extraño según la distribución dictada por la otra.\n",
        ">>\n",
        ">> **Respuesta.** Estimamos la distribución de las medias muestrales de 200 según la teoría que establece que p = 0,5. Con esta distribución, clasificamos los eventos en ordinarios y extraños. Luego, hallamos la media de una muestra de 200 generada por la segunda teoría, p = 2/3 = 0,66, y utilizamos la clasificación anterior para determinar si es ordinaria, lo que hace que ambas teorías sean compatibles, o extraña, lo que las hace incompatibles. El código es el siguiente."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1mNrCuE4x9x-"
      },
      "outputs": [],
      "source": [
        "# Program RejectingRivalTheory.py\n",
        "# We illustrate that two theories can be discriminated\n",
        "# if we gather enough data.\n",
        "# First theory: p = 0.5.\n",
        "# Second theory. p = 2/3.\n",
        "# Procedure:\n",
        "# 1. We fix n, the size of observed data.\n",
        "# 2. We estimate the distribution of\n",
        "# sample means of n data\n",
        "# generated according to the first theory, p = 0.5.\n",
        "# 3. We generate\n",
        "# $n$ random data according to the second theory, p = 2/3,\n",
        "# and find the \"observed mean\".\n",
        "# We classify that \"observed mean\" according to the\n",
        "# distribution found in the second step.\n",
        "# We  take the sample size n = 200 because\n",
        "# we already know that this suffices to\n",
        "# dicrimintae the two theories, i.e.\n",
        "# the \"observed mean\" becomes strange\n",
        "# according to the first theory.\n",
        "\n",
        "\n",
        "# Libraries and local rename\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "import statistics\n",
        "\n",
        "\n",
        "# 1. Parameters for the simulation\n",
        "num_coins_per_round = 20\n",
        "n = 200 # Size of each sample\n",
        "num_repetitions = 1000\n",
        "\n",
        "def mean_of_sample(sample_size, p):\n",
        "    heads_in_round = []\n",
        "    for j in range(sample_size):\n",
        "        heads = 0\n",
        "        for _ in range(num_coins_per_round):\n",
        "            # 0 for tails, 1 for heads\n",
        "            if p == 0.5:\n",
        "                # Probability of heads =  0.5\n",
        "                if random.choice([0, 1]) == 1:\n",
        "                    heads += 1\n",
        "            if p == 0.66:\n",
        "                # Probability of heads = 2/3 = 0.66\n",
        "                if random.choice([0, 1, 1]) == 1:\n",
        "                    heads += 1\n",
        "        heads_in_round.append(heads)\n",
        "    sample_mean = statistics.mean(heads_in_round)\n",
        "    return sample_mean\n",
        "\n",
        "\n",
        "def sample_mean_distribution(sample_size, p):\n",
        "    # Simulate coin flips\n",
        "    sample_means = []\n",
        "    for i in range(num_repetitions):\n",
        "        sample_means.append(mean_of_sample(sample_size, p))\n",
        "    # Calculate distribution\n",
        "    sample_means_distribution = Counter(sample_means)\n",
        "    return sample_means_distribution\n",
        "\n",
        "\n",
        "\n",
        "def graph_sample_mean_distribution(sample_means_distribution, n, p):\n",
        "    # Arrays to keep values to be graphed\n",
        "    x_values = []\n",
        "    y_values = []\n",
        "\n",
        "    # Print the results\n",
        "    print(\"Heads is 1 in a random choice among 0, 1\")\n",
        "    print(\"So, the probability of heads is 0.5\")\n",
        "    print(\"and that of tails is 0.5\")\n",
        "    print(f\"with {num_coins_per_round} coins per round:\")\n",
        "    print(f\"sample_mean of samples of size {n} rounds\")\n",
        "    print(f\"Simulation of {num_repetitions} repetitions \")\n",
        "\n",
        "    print(\"\\nDistribution of sample_means:\")\n",
        "    # Sort the distribution for better readability\n",
        "    sorted_distribution = dict(sorted(sample_means_distribution.items()))\n",
        "    for sample_mean, count in sorted_distribution.items():\n",
        "        x_values.append(sample_mean)\n",
        "        y_values.append(count)\n",
        "        print(f\"  {sample_mean} heads: {count} times\")\n",
        "\n",
        "    range_in = x_values[0]\n",
        "    range_out = x_values[len(x_values)-1]\n",
        "    range = range_out - range_in\n",
        "    print(f\"range_in: {range_in},  range_out: {range_out}, range = {range}\")\n",
        "\n",
        "    # Plot the function\n",
        "    plt.plot(x_values, y_values, label=\"Sample_means_distribution\")\n",
        "\n",
        "    # Add labels, title, and legend\n",
        "    plt.xlabel(\"Sample_mean\")\n",
        "    plt.ylabel(\"Count\")\n",
        "    plt.title(f\"Graph of sample means distribution, sample_size = {n}, p = {p}\")\n",
        "    plt.grid(True)\n",
        "    plt.legend()\n",
        "\n",
        "    # Display the plot\n",
        "    plt.show()\n",
        "\n",
        "def main():\n",
        "    # Probability of heads,\n",
        "    # only two possible values: 0.5 and 0.66\n",
        "    p = 0.5\n",
        "    sample_means_distribution = sample_mean_distribution(n, p)\n",
        "    graph_sample_mean_distribution(sample_means_distribution, n, p)\n",
        "    p = 0.66\n",
        "    mean = mean_of_sample(n, p) # n = sample_size\n",
        "    print(f\"Random sample of size = {n}, p = {p},  with mean  =  {mean}\")\n",
        "\n",
        "main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pTpDO1Egx9x-"
      },
      "source": [
        ">> Vemos claramente que la media de una muestra aleatoria de tamaño 200, generada por la teoría p = 0,66, está fuera del rango de la distribución estimada de medias muestrales con p = 0,5. Esto significa que un tamaño de muestra de 200 es suficiente para revelar la incompatibilidad de las dos teorías $p = 0,5$ y $p = 0,66$.\n",
        "\n",
        "> **Ejercicio**. Agregue al programa anterior un procedimiento para graficar las dos colas de eventos extraños para la distribución representada, correspondiente a la teoría $p = 0,5$, junto con una línea vertical que apunta al valor de la media muestral generada por la segunda teoría, $p = 0,66$.\n",
        "\n",
        "> **Respuesta.** El siguiente programa dibuja una estimación de la distribución de medias muestrales con medias muestrales de tamaño 200, generadas por la teoría que establece que $p = 0,5$. Los eventos extraños están coloreados en rojo con una significancia de $0,05$. A continuación, se construye una muestra de 200 a partir de la segunda teoría, que establece que $p = 0,66$. Se calcula y se dibuja su media para determinar si es normal o anormal según la primera teoría. Si esta media es normal, no se han recopilado suficientes datos para discriminarlas. Si esta media es anormal, se han recopilado suficientes datos para establecer la discriminación entre ambas teorías.\n",
        "El código es el siguiente: para colorear las regiones de rechazo, reutilizamos el código del programa `binomialDistriColoredTails2.py`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pEkdV8EZx9x-"
      },
      "outputs": [],
      "source": [
        "# Program RejectingRivalTheory2.py\n",
        "# We illustrate that two theories can be discriminated\n",
        "# if we gather enough data.\n",
        "# First theory: p = 0.5.\n",
        "# Second theory. p = 2/3.\n",
        "# Procedure:\n",
        "# 1. We fix n, the size of observed data.\n",
        "# 2. We estimate the distribution of\n",
        "# sample means of n data\n",
        "# generated according to the first theory, p = 0.5.\n",
        "# 3. We generate\n",
        "# $n$ random data according to the second theory, p = 2/3,\n",
        "# and find the \"observed mean\".\n",
        "# We classify that \"observed mean\" according to the\n",
        "# distribution found in the second step.\n",
        "# We  take the sample size n = 200 because\n",
        "# we already know that this suffices to\n",
        "# dicriminate the two theories, i.e.\n",
        "# the \"observed mean\" becomes strange\n",
        "# according to the first theory.\n",
        "\n",
        "\n",
        "# Libraries and local rename\n",
        "from matplotlib.collections import LineCollection\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np #Support for scientific computing\n",
        "import random\n",
        "from collections import Counter\n",
        "import statistics\n",
        "\n",
        "\n",
        "# Parameters for the simulation\n",
        "num_coins_per_round = 20\n",
        "n = 200 # Size of each sample\n",
        "num_repetitions = 5000\n",
        "# Initialization of the sample mean\n",
        "# according to the second theory p = 0.66\n",
        "mean_of_sample_2 = -1\n",
        "\n",
        "#Fabricate a sample and take the mean\n",
        "def mean_of_sample(sample_size, p):\n",
        "    heads_in_round = []\n",
        "    for j in range(sample_size):\n",
        "        heads = 0\n",
        "        for _ in range(num_coins_per_round):\n",
        "            # 0 for tails, 1 for heads\n",
        "            if p == 0.5:\n",
        "                # Probability of heads =  0.5\n",
        "                if random.choice([0, 1]) == 1:\n",
        "                    heads += 1\n",
        "            if p == 0.66:\n",
        "                # Probability of heads = 2/3 = 0.66\n",
        "                if random.choice([0, 1, 1]) == 1:\n",
        "                    heads += 1\n",
        "        heads_in_round.append(heads)\n",
        "    sample_mean = statistics.mean(heads_in_round)\n",
        "    # rounding to one decimal place\n",
        "    sample_mean = int(sample_mean * 10) / 10\n",
        "    return sample_mean\n",
        "\n",
        "\n",
        "# Simulate data to estimate the distribution of the sample mean.\n",
        "def sample_mean_distribution(sample_size, p):\n",
        "    # Simulate coin flips\n",
        "    sample_means = []\n",
        "    for i in range(num_repetitions):\n",
        "        sample_means.append(mean_of_sample(sample_size, p))\n",
        "    # Calculate distribution\n",
        "    sample_means_distribution = Counter(sample_means)\n",
        "    return sample_means_distribution\n",
        "\n",
        "\n",
        "\n",
        "def graph_sample_mean_distribution(sample_means_distribution, n, p):\n",
        "    # Arrays to keep values to be graphed\n",
        "    x_values = []\n",
        "    y_values = []\n",
        "\n",
        "    # Print the results\n",
        "    print(\"Heads is 1 in a random choice among 0, 1\")\n",
        "    print(\"So, the probability of heads is 0.5\")\n",
        "    print(\"and that of tails is 0.5\")\n",
        "    print(f\"with {num_coins_per_round} coins per round:\")\n",
        "    print(f\"sample_mean of samples of size {n} rounds\")\n",
        "    print(f\"Simulation of {num_repetitions} repetitions \")\n",
        "\n",
        "    print(\"\\nDistribution of sample_means:\")\n",
        "    # Sort the distribution for better readability\n",
        "    sorted_distribution = dict(sorted(sample_means_distribution.items()))\n",
        "    cumulate_frequency = 0\n",
        "    cumulate_frequencies = []\n",
        "    for sample_mean, count in sorted_distribution.items():\n",
        "        relative_frequency = 1.0 * count / num_repetitions\n",
        "        x_values.append(sample_mean)\n",
        "        y_values.append(relative_frequency)\n",
        "        cumulate_frequency += relative_frequency\n",
        "        cumulate_frequencies.append(cumulate_frequency)\n",
        "        print(f\" mean of heads: {sample_mean}, relative frequency: {relative_frequency} , cumulated : {cumulate_frequency}\")\n",
        "\n",
        "\n",
        "    ###  The graphic with  normal and abnormal events distinctly colored.\n",
        "\n",
        "    # fig, ax = plt.subplots()\n",
        "\n",
        "\n",
        "    bar_labels = []\n",
        "    bar_colors = []\n",
        "\n",
        "    left_tail = 0.0\n",
        "    real_alpha_half = -1.0\n",
        "\n",
        "    epsilon = 1e-7\n",
        "    for rel_freq in y_values:\n",
        "        print(f\"rel_freq = y_value =  {rel_freq}\")\n",
        "        left_tail += rel_freq\n",
        "        if left_tail < 0.025:\n",
        "            bar_labels.append('red')\n",
        "            bar_colors.append('tab:red')\n",
        "            real_alpha_half = left_tail\n",
        "            red_area = 2 * real_alpha_half\n",
        "            print(f\" left_tail = {left_tail} red\")\n",
        "        if  ((left_tail >= 0.025) and  (1-left_tail  + epsilon > real_alpha_half)) :\n",
        "            bar_labels.append('blue')\n",
        "            bar_colors.append('tab:blue')\n",
        "            print(f\"  {1-left_tail + epsilon} > {real_alpha_half}  blue\")\n",
        "        if (1-left_tail + epsilon) <= real_alpha_half:\n",
        "            bar_labels.append('red')\n",
        "            bar_colors.append('tab:red')\n",
        "            print(f\"  {1-left_tail + epsilon} <= {real_alpha_half}  red\")\n",
        "\n",
        "    # Automatic bar ploting: malfunctions\n",
        "    # ax.bar(x_values, y_values, label=bar_labels, color=bar_colors)\n",
        "    # ax.set_ylabel('Probability')\n",
        "    # ax.set_xlabel('Sample_mean')\n",
        "    # ax.set_title(f\"Sample Mean Distribution with rejection regions in red, area = {red_area:.4f}\")\n",
        "    # ax.legend(title='Bar color')\n",
        "    # plt.show()\n",
        "\n",
        "    print(\"real_alpha_half = \", real_alpha_half)\n",
        "    print( \"mean relat_Freq cumulate   bar_labels  bar_colors \")\n",
        "    for i in range(len(y_values)):\n",
        "        print(f\" {x_values[i]}     {y_values[i]}  {cumulate_frequencies[i]}  { bar_labels[i]}   {bar_colors[i]}\")\n",
        "\n",
        "    # We draw the bars as vertical lines\n",
        "    # Format: line = [(x1, y1), (x2, y2) ]\n",
        "    # Collection of bar lines, one for each x value\n",
        "    bar_collection = []\n",
        "    for i in range(len(x_values)):\n",
        "        my_bar = [(x_values[i], 0),(x_values[i], y_values[i])]\n",
        "        bar_collection.append(my_bar)\n",
        "        print(f\"{i}   {my_bar}\")\n",
        "    # Make a random sample according to p = 0.66 and take the mean\n",
        "    p = 0.66\n",
        "    mean_of_sample_2 = mean_of_sample(n, p)\n",
        "    print(f\"Random binomial sample of size = {n}, p = {p},  with mean  =  {mean_of_sample_2}\")\n",
        "\n",
        "    #Red long line marking a sample mean according to p = 0.66\n",
        "    bar_of_sample_mean_2 = [(mean_of_sample_2, 0),(mean_of_sample_2, 0.4)]\n",
        "    bar_collection.append(bar_of_sample_mean_2)\n",
        "    collection = LineCollection(bar_collection, color=bar_colors)\n",
        "    fig, axes = plt.subplots(1, 1)\n",
        "    axes.add_collection(collection)\n",
        "    axes.autoscale()\n",
        "    axes.set_ylabel('Probability')\n",
        "    axes.set_xlabel('Sample_mean')\n",
        "    axes.set_title(f\"Sample Mean Distribution for p = 0.5, sample size = 20, confidence = {red_area:.4f} \\n and  Observed sample mean for p = 0.66, red vertical line at the right.\")\n",
        "    plt.show()\n",
        "\n",
        "def main():\n",
        "    # The probability of heads has\n",
        "    # only two possible values: 0.5 and 0.66\n",
        "    p = 0.5 # The distribution of sample means is calculated for this theory\n",
        "    # n = sample_size\n",
        "    sample_means_distribution = sample_mean_distribution(n, p)\n",
        "    graph_sample_mean_distribution(sample_means_distribution, n, p)\n",
        "\n",
        "main()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qblYEM7wx9x-"
      },
      "source": [
        ">> El gráfico muestra claramente que\n",
        ">>> - Las medias muestrales según la primera teoría, p = 0,5, se sitúan muy cerca de la media esperada, en este caso, 10.\n",
        ">>> - La media muestral única según la segunda teoría, p = 2/3 = 0,66, se sitúa hacia arriba y se aleja mucho de la distribución observada de las medias muestrales según la primera teoría. Por lo tanto, dicha media muestral es muy extraña y, por lo consiguiente, la segunda teoría debe ser rechazada por la primera.\n",
        "\n",
        "# EL ORIGEN DE LA TENDENCIA AL ENCOGIMIENTO\n",
        "\n",
        "Las teorías deben madurar y explicar lo que inicialmente puede parecer un misterio. De lo contrario, se las olvida porque son como callejones sin salida, de los que no se puede avanzar.\n",
        "\n",
        "Así pues, expliquemos varios patrones observados relacionados con una regla muy práctica: ***Para ganar precisión, aumente el tamaño de la muestra.*** Este resultado se basa, en última instancia, en el hecho de que cuando el tamaño de la muestra aumenta, las campanas de las medias muestrales se angostan hacia su media. Y todo esto se basa en la tendencia de las distribuciones de ciertos observables a alcanzar una forma definida. Es esta precisión la que nos permite hacer predicciones que deben cumplirse. El material es prácticamente autocontenido y se ha hecho un esfuerzo para que sea comprensible.\n",
        "\n",
        "Concretamente, prestaremos atención a dos hechos que explicaremos a continuación: la tendencia de la frecuencia relativa de una Distribución Binomial hacia la probabilidad, y la de la media muestral de la Distribución Binomial a compactarse hacia la media esperada, concepto que merece mayor precisión.\n",
        "\n",
        "# El Valor Esperado\n",
        "\n",
        "La media de un conjunto de datos se obtiene sumando todos los datos y obteniendo el promedio dividiendo por la cantidad de datos. Por ejemplo, la media $\\overline{X}$ del conjunto de datos 3, 3, 4, 5, 5, 5 es:\n",
        "\n",
        "> $\\overline{X} = \\frac{3+3+4+5+5 +5}{6} = \\frac{25}{6}$\n",
        "\n",
        "Dado que algunos términos se repiten, podemos reescribir esta fracción utilizando frecuencias absolutas: la de 3 es 2, la de 4 es 1, la de 5 es 3. La media de este conjunto de datos se convierte en:\n",
        "\n",
        "> $\\overline{X} = \\frac{3 \\times 2 +4 \\times 1 +5\\times 3}{2 + 1 + 3} = \\frac{3 \\times 2 +4 \\times 1 +5\\times 3}{6} = \\frac{25}{6}$\n",
        "\n",
        "Si distribuimos la fracción, obtenemos la media en términos de frecuencias relativas:\n",
        "\n",
        "> $\\overline{X} = 3 \\times \\frac{2}{6} +4 \\times \\frac{1}{6} +5\\times \\frac{3}{6} = \\frac{25}{6}$.\n",
        "\n",
        "Esto nos permite definir la *fórmula general de la media* de un conjunto enumerable de datos $x_i$ en términos de sus frecuencias relativas $f_i$:\n",
        "\n",
        "> $\\overline{X} = \\sum x_i f_i $\n",
        "\n",
        "donde $x_i$ es el dato $i$ y $f_i$ es su frecuencia relativa.\n",
        "\n",
        "\n",
        "Las frecuencias relativas son observables. Deben compararse con lo que creemos. Por lo tanto, nos preguntamos: ¿cuál es ese elemento ideal que refleja la frecuencia relativa? Es la probabilidad, que en muchas ocasiones es simplemente una frecuencia relativa idealizada. En otras ocasiones, se corresponde con trabajos de ingeniería de precisión, por ejemplo, la construcción de un dado perfecto.\n",
        "\n",
        "> **Desafío.** Analice la siguiente regla, que es correcta: se permite decretar que una frecuencia relativa es una probabilidad cuando el tamaño de la muestra es lo suficientemente grande, digamos, 10 millones.\n",
        "\n",
        "Si queremos que el concepto de probabilidad sea útil, necesitamos establecer definiciones sólidas, como la siguiente, que es la idealización de la media de los datos observados:\n",
        "\n",
        "Sea $X$ una variable aleatoria con dominio discreto y enumerable. El ***Valor Esperado*** $E(X)$ de $X$ se define como:\n",
        ">\n",
        "> $E(X) = \\sum x_i p_i $\n",
        ">\n",
        "> donde $x_i$ es el valor $i$ y $p_i$ es su probabilidad. Con esto, requerimos que las frecuencias relativas observadas converjan a la probabilidad. Cabe destacar que esta no es una definición directamente vinculada a la observación, sino a ideas, ya que la probabilidad es, en primer lugar, un concepto mental. El único requisito es que los valores $x_i$ sean observables. Por lo tanto, una variable aleatoria discreta debe definirse como una función que asocia probabilidades a eventos resultantes de mediciones representadas por números enteros no negativos: 0, 1, 2,...\n",
        "\n",
        "> **Ejemplo.** Para una distribución binomial o una variable aleatoria binaria que cuenta el número de caras al lanzar 20 monedas, $x_i = i$ representa el número de caras y va de $0$ a $20$. Al mismo tiempo, $p_i$ viene dado por la expansión binomial que representa lo que pensamos.\n",
        "\n",
        "> **Ejemplo.** Calculemos el valor esperado de la distribución binomial que cuenta caras con 1 moneda y una probabilidad de cara $p$. La variable aleatoria correspondiente $X_1$ es la función definida por:\n",
        ">>>\n",
        ">>> $0 \\rightarrow q = 1-p$\n",
        ">>>\n",
        ">>> $1 \\rightarrow p$\n",
        ">>>\n",
        ">> El valor esperado de $X_1$ es:\n",
        ">>>\n",
        ">>> $E(X_1) = 0\\times q + 1 \\times p = p$\n",
        "\n",
        "> **Ejemplo.** Calculemos el valor esperado de la distribución binomial con 2 monedas y una probabilidad de cara $p$. La variable aleatoria correspondiente $X_2$ es la función definida por\n",
        ">\n",
        "> $0 \\rightarrow q^2$\n",
        ">\n",
        "> $1 \\rightarrow 2pq$\n",
        ">\n",
        "> $2 \\rightarrow p^2$\n",
        ">\n",
        "> y 0 en caso contrario.\n",
        ">\n",
        "> El valor esperado de $X_2$ es la suma de los productos de los valores por sus probabilidades:\n",
        ">>\n",
        ">> $E(X_2) = 0\\times q^2 + 1 \\times 2pq + 2 \\times p^2 = 2pq + 2p^2 = 2p(q +p) = 2p$\n",
        "\n",
        "> **Ejercicio.**  El valor esperado de la distribución binomial con 1 moneda era $p$ y con 2 monedas era $2p$. ¿Es $3p$ para 3 monedas? Explica tu resultado con sentido común.\n",
        ">>\n",
        ">> **Respuesta.** Para saber si $3p$ es el valor esperado de una distribución binomial con 3 monedas, debemos calcularlo. Sea $X_3$ la variable aleatoria que representa la distribución binomial con 3 monedas. Es la función definida por\n",
        ">>>\n",
        ">>> $0 \\rightarrow q^3$\n",
        ">>>\n",
        ">>> $1 \\rightarrow 3q^2p$\n",
        ">>>\n",
        ">>> $2 \\rightarrow 3qp^2$\n",
        ">>>\n",
        ">>> $3 \\rightarrow p^3$\n",
        ">>>\n",
        ">>> y su Valor Esperado es:\n",
        ">>>\n",
        ">>> $E(X_3) = 0 \\times q^3 + 1 \\times 3q^2p + 2 \\times 3qp^2 +3 \\times p^3$\n",
        ">>>\n",
        ">>> $ = 3q^2p + 6qp^2 + 3p^3 = 3p (q^2 + 2 pq + p^2) = 3p(p+q)^2 = 3p$.\n",
        "\n",
        "Dado que hemos verificado que el Valor Esperado para 3 monedas es $3p$, postulemos que el Valor Esperado de la Distribución Binomial con parámetro $p$ y $n$ monedas es $np$. Este resultado indica que si lanzamos $n$ monedas, podemos esperar $np$ caras. Por ejemplo, si $p = 1/2$ y lanzamos la moneda 10 veces, esperamos $10 \\times (1/2) = 5$ caras. En un experimento real, rara vez obtendremos 5 caras, pero los valores se apilarán alrededor de 5 con una distribución dada por la Expansión Binomial.\n",
        "\n",
        "Para continuar con el estudio de nuestro postulado, necesitamos dos propiedades del Valor Esperado de las variables aleatorias.\n",
        "\n",
        "- La primera es: Si todos los valores se multiplican por una constante $c$, el Valor Esperado también se multiplica por la misma constante:\n",
        ">>\n",
        ">> $E(cX) = c E(X) $\n",
        "\n",
        "> **Ejemplo.** Imaginemos a un vendedor de herramientas cuyos ingresos mensuales dependen del volumen de ventas. Esto es aleatorio, pero homogéneo a lo largo del tiempo. Por lo tanto, es lógico hablar de probabilidades de ganar 1000, 2000, etc. También es comprensible que, ocasionalmente, las herramientas, que son indispensables, se encarezcan. En consecuencia, los ingresos aumentarán. Esta regla establece que el valor esperado de sus ingresos se multiplica por una constante $c$ si los ingresos de cada mes se multiplican por la misma constante.\n",
        "\n",
        "- La segunda regla se refiere a la suma de variables aleatorias. Imaginemos a una pareja de vendedores cuyos ingresos dependen de las ventas. Estas variables son aleatorias, pero homogéneas a lo largo del tiempo. Por lo tanto, es lógico hablar de probabilidades de ganar 1000, 2000,.., 6000. Esta regla establece que el valor esperado de los ingresos de la pareja es la suma de los valores esperados de cada miembro de la pareja. Más específicamente: El valor esperado de la suma de dos variables aleatorias es la suma de los valores esperados de cada variable. Sean $X$ e $Y$ los ingresos, entonces:\n",
        ">>\n",
        ">> $E(X+Y) = E(X) + E(Y)$\n",
        "\n",
        "Veamos una aplicación directa de estas reglas.\n",
        "\n",
        "> **Ejemplo.** Hemos postulado que el valor esperado de la $Bi(n,p)$ es $np$. Podríamos usar álgebra para demostrar el postulado para algunos valores, 4, 5 y 7. ¿Y el resto? ¿Cómo podemos pasar de un postulado a un teorema?\n",
        ">>\n",
        ">> Cuando se debe demostrar una proposición sobre los números 0, 1, 2, ..., usamos el principio de inducción: Demostramos la proposición para un solo caso, que podría ser 1, y luego demostramos que siempre podemos demostrar que la proposición es válida para $n+1$ suponiendo que es válida para $n$. Usemos este principio para demostrar que el valor esperado de la distribución binomial es $np$ para cada $n$.\n",
        ">>\n",
        ">> Paso 1: ¿Es válido para 1? Sí, eso ya se demostró.  \n",
        ">> Paso 2: Supongamos que la proposición es válida para $n$, es decir, que el valor esperado de la $Bi(n,p)$ es $np$. A partir de esto, debemos demostrar que el valor esperado de  la $Bi(n+1,p)$ es $(n+1)p$.\n",
        ">>\n",
        ">> Ahora, $Bi(n+1,p) = Bi(n,p) + Bi(1,p)$, lo que significa que un juego con $n+1$ monedas es simplemente un juego con $n$ monedas más otra moneda. Más claramente, lanzamos $n$ monedas, contamos caras y, luego, lanzamos otra moneda, observamos si sale cara; en ese caso, sumamos 1 al número de caras encontrado previamente.\n",
        ">>\n",
        ">> Dado que el Valor Esperado es compatible con la suma de variables aleatorias y con la multiplicación por una costante, tenemos:\n",
        ">>>\n",
        ">>> $E(Bi(n+1,p)) = E(Bi(n,p)) + E(Bi(1,p)) =  np + p = (n+1)p$\n",
        ">>>\n",
        ">> como se desea. Hemos probado un resultado importante que dice:\n",
        "\n",
        "> **Teorema.** El Valor Esperado de la Distribución Binomial  $Bi(n,p)$ es $np$.\n",
        "\n",
        "Podría ser instructivo tratar de probar por inducción una proposición falsa, digamos\n",
        ">\n",
        ">> $E(Bi(n,p)) = np + (n-1)p$:\n",
        ">\n",
        "> Paso 1: Es válida para $n= 1$?\n",
        ">>\n",
        ">> $E(Bi(1,p)) = 1p + (1-1)p = p$, una afirmación que es correcta.\n",
        ">>\n",
        "> Paso 2: Supongamos que la proposición es válida para $n$, es decir, el valor esperado de $Bi(n,p)$ es $np + (n-1)p$. A partir de esto, debemos demostrar que el valor esperado de $Bi(n+1,p)$ es\n",
        ">>\n",
        ">> $E(Bi(n+1,p)) = (n+1)p + (n+1-1)p = (n+1)p + np = np + p + np = 2np + p$.\n",
        ">\n",
        ">¿Es esto cierto? Veamos:\n",
        ">>\n",
        ">> $E(Bi(n+1,p)) = E(Bi(n,p)) + E(Bi(1,p)= np + (n-1)p + p = np + np -p + p = 2np $\n",
        ">>\n",
        ">> que es diferente de $2np + p$. Por lo tanto, la proposición es falsa.\n",
        "\n",
        "> **Ejemplo.** Sean $X$ e $Y$ variables aleatorias que toman valores en el conjunto 1, 2,..., 6 (en miles) con probabilidades iguales a $1/6$. Estas variables representan las entradas aleatorias de una pareja. Entonces, el valor esperado de cada variable es:\n",
        ">>\n",
        ">> $E(X) = E(Y) = 1 \\times \\frac{1}{6} + 2 \\times \\frac{1}{6} + 3 \\times \\frac{1}{6} + 4 \\times \\frac{1}{6} + 5 \\times \\frac{1}{6} + 6 \\times \\frac{1}{6} = \\frac{21}{6} = 3.5$\n",
        ">>\n",
        ">> Por lo tanto, el valor esperado de los ingresos familiares es:\n",
        ">>\n",
        ">> $E(X+Y) = E(X) + E(Y) = \\frac{21}{6} + \\frac{21}{6} = \\frac{42}{6} = 7$\n",
        "\n",
        "Es curioso que hayamos encontrado el valor esperado de los ingresos de la pareja $Z = X + Y$, aunque no tenemos idea de qué es $Z$. Así que, intentemos comprender su naturaleza. El problema es que si el esposo gana 2, no podemos determinar cuál podría ser la ganancia de la esposa. Solo podemos asumir que trabajan en distritos diferentes, por lo que no compiten; por lo tanto, sus ganancias son aleatorias pero no están correlacionadas.\n",
        "\n",
        "La siguiente tabla nos ayuda a descifrar el valor de $Z = X + Y$:\n",
        "\n",
        "Z | 1 & 2 & 3 & 4 & 5 & 6     \n",
        "1 | 2 & 3 & 4 & 5  & 6  & 7    \n",
        "2 | 3 & 4 & 5 & 6  & 7  & 8     \n",
        "3 | 4 & 5 & 6 & 7  & 8  & 9     \n",
        "4 | 5 & 6 & 7 & 8  & 9  & 10     \n",
        "5 | 6 & 7 & 8 & 9  & 10  & 11     \n",
        "6 | 7 & 8 & 9 & 10 & 11 & 12     \n",
        "\n",
        "Vemos en la primera columna los posibles valores de $X$, en la primera fila los de $Y$ y en las otras 6 filas, la suma de $X$ e $Y$. El código Latex para esta tabla es el siguiente:\n",
        "\n",
        "\n",
        "\\begin{center}\n",
        "\\begin{tabular}[c]{|r||rrrrrr|} \\hline  \\hline\n",
        "\\multicolumn{7}{|c|}{ Table of Z = X + Y} \\\\ \\hline \\hline\n",
        "X ($\\downarrow)$ and Y ($\\rightarrow$)& 1 & 2 & 3 & 4 & 5 & 6\\\\ \\hline \\hline\n",
        "1 & 2 & 3 & 4 & 5 & 6 & 7\\\\\n",
        "2 & 3 & 4 & 5 & 6 & 7 & 8\\\\\n",
        "3 & 4 & 5 & 6 & 7 & 8 & 9\\\\\n",
        "4 & 5 & 6 & 7 & 8 & 9 & 10\\\\\n",
        "5 & 6 & 7 & 8 & 9 & 10 & 11\\\\\n",
        "6 & 7 & 8 & 9 & 10 & 11 & 12\\\\ \\hline\n",
        "\\end{tabular}\n",
        "\\end{center}\n",
        "\n",
        "\n",
        "Así que $Z = X + Y$ es la variable aleatoria que toma valores en 2, 3,..., 12 con las siguientes probabilidades:\n",
        ">\n",
        "> $2 \\rightarrow 1/36$\n",
        ">\n",
        "> $3 \\rightarrow 2/36$\n",
        ">\n",
        "> $4 \\rightarrow 3/36$\n",
        ">\n",
        "> $5 \\rightarrow 4/36$\n",
        ">\n",
        "> $6 \\rightarrow 5/36$\n",
        ">\n",
        "> $7 \\rightarrow 6/36$\n",
        ">\n",
        "> $8 \\rightarrow 5/36$\n",
        ">\n",
        "> $9 \\rightarrow 4/36$\n",
        ">\n",
        "> $10 \\rightarrow 3/36$\n",
        ">\n",
        "> $11 \\rightarrow 2/36$\n",
        ">\n",
        "> $12 \\rightarrow 1/36$\n",
        ">\n",
        ">  Test: La suma de todas las probabilidades debe dar 1. ¿Es cierto?  \n",
        ">\n",
        "> Sí: la suma de los numeradores es 1 + 2 + 3 + 4 + 5+ 6 + 5 + 4 + 3 + 2 +1 = 36. Como el denominador es 36, la suma de las probabilidades da 1.\n",
        ">\n",
        "> Predicción. El Valor Esperado de $Z$ es la suma de los Valores Esperados de $X$ y $Y$, i.e., $3.5 + 3.5 = 7$. ¿Es eso verdad? Veamos:\n",
        ">\n",
        ">> $E(Z) = \\frac{2}{36} + \\frac{6}{36} +\\frac{12}{36} +\\frac{20}{36} +\\frac{30}{36} +\\frac{42}{36} +\\frac{40}{36} +\\frac{36}{36} +\\frac{30}{36} +\\frac{22}{36} +\\frac{12}{36}  = \\frac{252}{36} = 7$\n",
        ">\n",
        "> Por lo tanto, es cierto que el Valor Esperado es $7$. Se verificó la regla de la suma de los Valores Esperados de variables aleatorias. ¿Y qué hay de la demostración general?\n",
        "\n",
        "> *Investigación.* La demostración general de la proposición de que el Valor Esperado de las variables aleatorias es lineal, es decir, compatible tanto con la multiplicación por un escalar o número como con la suma de variables aleatorias, ya existe. Revisa la demostración que ofrece Wikipedia e intenta comprenderla:\n",
        ">\n",
        "> https://statproofbook.github.io/P/mean-lin\n",
        "\n",
        "> **Desafío.** En el ejemplo anterior, $X$ e $Y$ abstrajeron un juego con un dado, en el que todas las caras caen hacia arriba con la misma probabilidad $1/6$. Este es un ejemplo de una Distribución Uniforme, cuyo gráfico es una línea horizontal. Pero la forma de la distribución de $X + Y$, abstrayendo un juego con dos dados en el que la suma es lo que cuenta, no es uniforme. Tiene forma de montaña. Haz un pronóstico para tres dados, $X + X + X$, y compruébalo. ¿Adivinarías qué podría pasar con una suma de muchos términos $X + X + ... + X$? ¿Es una feliz coincidencia o es algo general?\n",
        "\n",
        "Consideramos que hemos comprendido bien qué es el Valor Esperado de una variable aleatoria. Ahora, podemos ir un paso más allá: comprender por qué y cómo la media muestral tiende a agolparse alrededor del Valor Esperado. Para demostrarlo, necesitamos saber cómo medir la dispersión de una variable aleatoria. Procedamos.\n",
        "\n",
        "# La dispersión de una variable aleatoria\n",
        "\n",
        "Ya sabemos que la suma de las desviaciones con respecto a la media de un conjunto de datos se equilibra pues suman cero. Sin embargo, las desviaciones también indican la dispersión de los datos. Para recuperar este significado, elevamos al cuadrado todas las desviaciones y tomamos la media:\n",
        ">\n",
        "> $V (x) =   \\frac{\\sum (x_i - \\overline{x})^2}{n}$.\n",
        "\n",
        "> **Ejemplo.** Sean los datos 4, 5, 6. Su media es\n",
        ">>\n",
        ">> $\\overline{x} = \\frac{4+5 + 6}{3} = \\frac{15}{3} = 5$\n",
        ">>\n",
        ">> La varianza es $V(X)$:\n",
        ">>\n",
        ">> $V (x) = \\frac{ (4- 5)^2 + (5-5 )^2  + (6-5 )^2 }{n} = \\frac{ (-1)^2 + (0 )^2  + (1 )^2 }{3} = \\frac{1+1}{3} = \\frac{2}{3}$.\n",
        "\n",
        "¿Cómo debemos definir la varianza de una variable aleatoria $X$? Tomamos la desviación de la media, es decir, del Valor Esperado, la elevamos al cuadrado y calculamos el promedio. El Valor Esperado es $E(X)$, las desviaciones de este valor son $(X - E(X))$, cuyo cuadrado es $(X - E(X))^2$, y para finalizar, calculamos el promedio, es decir, el Valor Esperado. Por lo tanto, ***la varianza $V$ de la variable aleatoria $X$*** es\n",
        "\n",
        "> $V(X) = E[(X - E(X))^2] = E(X - E(X))^2$.\n",
        "\n",
        "La varianza es una medida de dispersión o variación de conjuntos de datos y variables aleatorias. Cuanto mayores sean las desviaciones de la media, mayor será la varianza. Al ser un valor esperado o promedio, es muy robusta frente a cambios en las muestras, pero puede verse distorsionada por valores atípicos, que son eventos muy extraños.\n",
        "\n",
        "Se utilizarán dos propiedades de $V$:\n",
        "\n",
        "- Si todos los datos se multiplican por una constante $c$, la varianza se multiplica por la misma constante al cuadrado, ya que las desviaciones se elevan al cuadrado.\n",
        ">>\n",
        ">> $V(cX) = E(cX- E(cX))^2 = E(cX- cE(X))^2 = E(c(X- E(X)))^2 = E(c^2(X- E(X))^2) = c^2E(X- E(X))^2 = c^2 V(X) $\n",
        "\n",
        "- La Varianza de una suma es la suma de las varianzas más un residuo que podría ser cero.  \n",
        ">>\n",
        ">> $V(X+ Y) = E(X + Y - E(X + Y))^2 = E(X + Y - E(X) - E( Y))^2  $\n",
        ">>\n",
        ">> $  =  E[ (X - E(X))+ (Y - E( Y))]^2 $\n",
        ">>\n",
        ">> $ = E[(X - E(X))^2+ (Y  - E( Y))^2 + 2(X - E(X)) (Y  - E( Y))]$\n",
        ">>\n",
        ">> $ = E(X - E(X))^2+ E(Y  - E( Y))^2 + 2E[(X - E(X)) (Y  - E( Y))]$\n",
        ">>\n",
        "> Hemos obtenido\n",
        ">>\n",
        ">> $V(X+ Y) = V(x) + V(Y) + 2E[(X - E(X)) (Y  - E( Y))]$\n",
        "\n",
        "El residuo $2E[(X - E(X)) (Y - E( Y))]$ tiene un significado: es el doble del promedio de los productos de las desviaciones de sus medias correspondientes de las variables aleatorias $X$ e $Y$. Para obtener un valor distinto de cero, dichas desviaciones deben tener el mismo signo en la mayoría de los casos, y las dos variables deben oscilar coordinadamente alrededor de sus valores medios. Decimos que están correlacionadas. Pero si las variables son independientes, los términos del residuo se cancelarán entre sí porque no están correlacionados. Este es precisamente el caso con nuestras monedas: el resultado de un lanzamiento no influye en ningún otro. De esta manera, hemos demostrado el siguiente resultado, que se utilizará en la secuela:\n",
        "\n",
        ">> **Teorema.** La varianza de una suma de variables aleatorias independientes es la suma de las varianzas.\n",
        "\n",
        "Pasemos ahora a los cálculos específicos.\n",
        "\n",
        "# Varianza de la Distribución Binomial\n",
        "\n",
        "Calculemos la varianza de la Distribución Binomial en los casos más simples.\n",
        "\n",
        "> **Ejemplo.** Calculemos la varianza de la distribución binomial para $n=1$. La variable aleatoria correspondiente $X_1$ es la función definida por\n",
        ">>\n",
        ">> $0 \\rightarrow q = 1-p$\n",
        ">>\n",
        ">> $1 \\rightarrow p$\n",
        ">>\n",
        ">>  El Valor Esperado de $X_1$ es\n",
        ">>\n",
        ">>> $E(X_1) = 0\\times q + 1 \\times p = p$\n",
        ">>\n",
        ">> La varianza de  $X_1$ es\n",
        ">>\n",
        ">>> $V(X_1) = (0-p)^2 q + (1-p)^2 p $\n",
        ">>>>  \n",
        ">>>> $= p^2q + (1 -2p + p^2)p $\n",
        ">>>>\n",
        ">>>> $= p^2q + p -2p^2 + p^3 $\n",
        ">>>>\n",
        ">>>> $= p + p^2(q-2+p) $\n",
        ">>>>\n",
        ">>>> $= p + p^2(q +p -2) $\n",
        ">>>>\n",
        ">>>> $=  p + p^2(1 -2) $\n",
        ">>>>\n",
        ">>>> $= p + p^2(-1) = p - p^2 = p (1-p) = pq$\n",
        "\n",
        "> **Ejemplo.** Calculemos la varianza de la Distribución Binomial para $n=2$.  La variable aleatoria correspondiente $X_2$ es la función definida por\n",
        ">>\n",
        ">> $0 \\rightarrow q^2$\n",
        ">>\n",
        ">> $1 \\rightarrow 2pq$\n",
        ">>\n",
        ">> $2 \\rightarrow p^2$\n",
        ">>\n",
        ">> No queremos calcular esta varianza a partir de la definición. Preferimos usar las propiedades de las varianzas. Por lo tanto, $X_2 = X_1 + X_1$, lo que significa que el número de caras en un juego con dos monedas es igual a la suma del resultado de dos juegos, ambos con una moneda. Tenemos:\n",
        ">>>\n",
        ">>> $V(X_2) = V(X_1) + V(X_1)$\n",
        ">>\n",
        ">> donde hemos usado el hecho de que jugar con una moneda no interfiere con los resultados del juego con la segunda. Por lo tanto, se trata de variables aleatorias independientes no correlacionadas. Por consiguiente,\n",
        ">>>\n",
        ">>> $V(X_2) = pq + pq = 2pq$\n",
        "\n",
        "Sin embargo, hemos arrastrado un vacío: creemos por instinto que $X_2 = X_1 + X_1$, pero en ciencia, nuestro instinto se sustenta mejor con una demostración.\n",
        "\n",
        "> **Ejercicio.** Demuestre que $X_2 = X_1 + X_1$. Observe que, según nuestra conceptualización, $X_1 + X_1$ es muy diferente de $2X_1$.\n",
        ">>\n",
        ">> **Respuesta.** Como $X_1$ es la función definida por\n",
        ">>>\n",
        ">>> $0 \\rightarrow q = 1-p$\n",
        ">>>\n",
        ">>> $1 \\rightarrow p$\n",
        ">>>\n",
        ">>> Con esto, podemos crear la tabla de la suma de $X_1 + X_1$, teniendo en cuenta que las caras se suman y que las probabilidades se multiplican por tratarse de eventos independientes. El  código Latex de la tabla de la suma  es:\n",
        ">>>\n",
        ">>>> \\begin{center}\n",
        "\\begin{tabular}[c]{|c||c|c|} \\hline\n",
        "\\multicolumn{3}{|c|}{ Table of $Z = X_1 + X_1$} \\\\ \\hline \\hline\n",
        "$X_1$ ($\\downarrow)$ and $X_1$ ($\\rightarrow$)& 0 $\\rightarrow q$ & 1  $\\rightarrow p$  \\\\ \\hline \\hline\n",
        "0 $\\rightarrow q$  & 0 $\\rightarrow q^2$  & 1 $\\rightarrow qp$  \\\\ \\hline\n",
        "1  $\\rightarrow p$  & 1 $\\rightarrow pq$  & 2 $\\rightarrow p^2$ \\\\ \\hline  \n",
        "\\end{tabular}\n",
        "\\end{center}\n",
        ">>>\n",
        ">>> Esta tabla tiene la apariencia siguiente:\n",
        ">>>\n",
        ">>> $  ---- $& 0 $\\rightarrow q$ & 1  $\\rightarrow p$   \n",
        "0 $\\rightarrow q$   & 0 $\\rightarrow q^2$  & 1 $\\rightarrow qp$    \n",
        "1  $\\rightarrow p$  & 1 $\\rightarrow pq$  & 2 $\\rightarrow p^2$    \n",
        ">>\n",
        ">> Por consiguiente, la variable aleatoria $X_1 + X_1$ es la función definida por\n",
        ">>\n",
        ">>> $0 \\rightarrow q^2$\n",
        ">>>\n",
        ">>> $1 \\rightarrow 2pq$\n",
        ">>>\n",
        ">>> $2 \\rightarrow p^2$\n",
        ">>>\n",
        ">> la cual coincide con $X_2$.\n",
        "\n",
        "\n",
        "> **Ejercicio.** Calcula la varianza de $X_3$, la variable aleatoria cuyas asignaciones de probabilidad surgen de la expansión binomial con $n = 3$.\n",
        ">>\n",
        ">> **Respuesta.** La variable aleatoria $X_3$ representa un juego con tres monedas en el que sumamos los resultados de tres juegos idénticos. Por lo tanto, afirmamos que $X_3 = X_1 + X_1 + X_1 = X_2 + X_1$. Demostrémoslo. El código Latex de la tabla correspondiente es:\n",
        ">>>\n",
        ">>> \\begin{center}\n",
        "\\begin{tabular}[c]{|c||c|c|} \\hline\n",
        "\\multicolumn{3}{|c|}{ Table of $Z = X_1 + X_1 + X_1 = X_2 + X_1$} \\\\ \\hline \\hline\n",
        "$X_2$ ($\\downarrow)$ and $X_1$ ($\\rightarrow$)& 0 $\\rightarrow q$ & 1  $\\rightarrow p$  \\\\ \\hline \\hline\n",
        "0 $\\rightarrow q^2$  & 0 $\\rightarrow q^3$  & 1 $\\rightarrow q^2p$  \\\\ \\hline\n",
        "1  $\\rightarrow 2qp$  & 1 $\\rightarrow 2q^2p$  & 2 $\\rightarrow 2qp^2$ \\\\ \\hline\n",
        "2  $\\rightarrow  p^2$  & 2 $\\rightarrow qp^2$  & 3 $\\rightarrow p^3$ \\\\ \\hline  \n",
        "\\end{tabular}\n",
        "\\end{center}\n",
        ">>>\n",
        ">> La apariencia de esta tabla es como sigue:\n",
        ">>>\n",
        ">>> $X_2$  y $X_1$   & 0 $\\rightarrow q$      & 1  $\\rightarrow p$      \n",
        "0  $\\rightarrow q^2$   & 0 $\\rightarrow q^3$    & 1 $\\rightarrow q^2p$     \n",
        "1  $\\rightarrow 2qp$   & 1 $\\rightarrow 2q^2p$  & 2 $\\rightarrow 2qp^2$     \n",
        "2  $\\rightarrow  p^2$  & 2 $\\rightarrow qp^2$   & 3 $\\rightarrow p^3$      \n",
        ">>   \n",
        ">> Por consiguiente, la variable aleatoria $X_1 + X_1 + X_1$ es la función definida por\n",
        ">>>\n",
        ">>> $0 \\rightarrow q^3$\n",
        ">>>\n",
        ">>> $1 \\rightarrow 3q^2p$\n",
        ">>>\n",
        ">>> $2 \\rightarrow 3qp^2$\n",
        ">>>\n",
        ">>> $3 \\rightarrow p^3$\n",
        ">>>\n",
        ">> la cual coincide con $X_3$.\n",
        ">>\n",
        ">> Vemos que la varianza de $X_3$ es la de $X_1 + X_1 + X_1$, la cual es\n",
        ">>>\n",
        ">>> $V(X_3) = qp + qp + qp = 3pq$\n",
        "\n",
        "> **Ejercicio.** Generalizar: Hallar la varianza de la Distribución Binomial en general.\n",
        "\n",
        ">> **Respuesta.** La varianza de la Distribución Binomial con $n$ monedas es $npq$. Demostración por inducción:\n",
        ">>>\n",
        ">>> Paso 1: Como se halló anteriormente, la varianza de la Distribución Binomial con 1 moneda es $pq$, por lo que la fórmula es válida para este caso.\n",
        ">>>\n",
        ">>> Paso 2: Pasemos del paso $k$ al paso $k+1$. Supongamos que la varianza de $X_k$ es $kpq$. Ahora bien,\n",
        ">>>\n",
        ">>>> $X_{k+1} = X_k + X_ 1$ y son independientes. Por lo tanto, la varianza es\n",
        ">>>>\n",
        ">>>> $V(X_{k+1}) = V(X_k) + V(X_ 1) = kpq + pq = (k+1)pq$,\n",
        ">>>>\n",
        ">>>> tal como se solicita.\n",
        ">>\n",
        ">> En resumen, la fórmula es válida para $k = 1$, y si asumimos que es válida para $k$, podemos demostrar que es válida para $k+1$. En consecuencia, es válida para todo $k$.\n",
        "\n",
        "> **Ejercicio.** Sea $X$ la variable aleatoria que cuenta caras en una distribución binomial con $n$ monedas y probabilidad de cara $p$. Demuestre que la distribución de su frecuencia relativa $X/n$ se reduce o converge hacia el valor esperado cuando $n$ crece.\n",
        ">>\n",
        ">> **Respuesta.** El valor esperado de $X$ es $np$ y su varianza es $V(X) = npq$. La frecuencia relativa de una distribución binomial $X$ con $n$ monedas es $X/n$. Por lo tanto, el valor esperado de la frecuencia relativa $X/n$ es\n",
        ">>>\n",
        ">>> $E(X/n) = \\frac{E(X)}{n} = \\frac{np}{n} = p$\n",
        ">>>\n",
        ">> y su varianza, o dispersión con respecto a su valor esperado $p$, es\n",
        ">>>\n",
        ">>> $V(X/n) = \\frac{V(X)}{n^2} = \\frac{npq}{n^2} = \\frac{pq}{n} \\rightarrow 0$\n",
        ">>>\n",
        ">> Esta convergencia a cero explica por qué la frecuencia relativa de una distribución binomial tiende a $p$ y se reduce hacia ella a medida que aumenta el número de monedas.\n",
        "\n",
        "> **Ejercicio.** Explique en qué consiste la media muestral $\\overline{Y_n}$ de una variable aleatoria general $Y$. De un ejemplo.\n",
        ">>\n",
        ">> **Respuesta.** Una variable aleatoria $Y$ puede considerarse como una fuente de números aleatorios, con una distribución determinada por $Y$. La media muestral consiste en seleccionar un número dado $n$, tomar $n$ datos de la fuente, sumarlos y promediar sobre $n$. A continuación, debemos repetir esta tarea tantas veces como sea posible para obtener una estimación de la distribución correspondiente.\n",
        ">>>\n",
        ">>> Por ejemplo, si $Y$ es la variable aleatoria que mide la altura de las personas adultas, toma valores de 1 m a 2,8 m. La media muestral con $n = 30$ consiste en tomar 30 personas al azar, medir sus alturas y promediar. Esto corresponde a 1 valor de la media muestral. A continuación, debemos repetir este procedimiento una y otra vez para comprender mejor la forma de la distribución correspondiente. Por eso definimos la *Media Muestral* de $Y$ sobre muestras al azar de tamaño $n$\n",
        ">>>\n",
        ">>>> $\\overline{Y_n} = \\frac{\\sum_{i = 1}^n Y_i}{n}$\n",
        ">>>\n",
        ">>> donde todos los $Y_i$ tienen la misma distribución que $Y$ y son independientes.\n",
        ">>>\n",
        ">>> Una teoría plausible de la altura afirma que, a partir de 1 m, cada 10 cm de altura adicional se debe a una copia activa de un gen de crecimiento, que puede estar activado o desactivado con igual probabilidad. Por lo tanto, si tienes 7 copias activas, tu altura es de 1,7 m. La altura total viene dada por $Y = 1 + 0,1X$, donde $X$ es la variable aleatoria con una distribución binomial con $18$ monedas y $p = 0,5$. La media muestral $Y_n$ se convierte en este caso en:\n",
        ">>>>\n",
        ">>>> $\\overline{Y_n} = \\frac{\\sum_{i = 1}^n (1 + 0,1X)}{n}$\n",
        ">>>\n",
        ">>> y cada $X$ es una Binomial $Bi(18, 0.5)$,\n",
        "\n",
        "> **Ejemplo.** Demostremos que la distribución de la media muestral de una variable aleatoria binaria se recoje hacia la media.\n",
        ">>\n",
        ">> Demostración. Usamos la varianza como medida de dispersión de distribuciones. Una variable aleatoria binaria $Y = X_m$, con $m$ monedas, tiene media $mp$ y varianza $mpq$. Sea $\\overline{Y_n}$ su media muestral con $n$ datos:\n",
        ">>>\n",
        ">>> $\\overline{Y_n} = \\frac{\\sum_{i = 1}^n Y_i}{n}$\n",
        ">>\n",
        ">> donde cada $Y_i$ es una copia de $Y$.\n",
        ">>\n",
        ">> Suponemos que la fuente de los números aleatorios permanece igual independientemente de cuántos datos se hayan generado. Esto implica que los $Y_i$ son independientes. Por ejemplo, esto ocurre con una variable aleatoria binaria cuando la moneda no se rompe, ni se gasta, después de jugar con ella. Entonces\n",
        ">>>\n",
        ">>> $V(\\overline{Y_n}) = V(\\frac{\\sum_{i = 1}^n Y_i}{n}) $\n",
        ">>>\n",
        ">>> $= \\frac{1}{n^2} V( \\sum_{i = 1}^n Y_i ) $\n",
        ">>>\n",
        ">>> $= \\frac{1}{n^2}  \\sum_{i = 1}^n V(Y_i )$\n",
        ">>>\n",
        ">>> $ = \\frac{1}{n^2}  \\sum_{i = 1}^n mpq  $\n",
        ">>>\n",
        ">>> $ = \\frac{n}{n^2}    mpq  = \\frac{mpq}{n}  \\rightarrow 0$\n",
        ">>>\n",
        ">> Esto demuestra que la Media Muestral se encoge hacia el Valor Esperado cuando $n$ diverge hacia el infinito.\n",
        "\n",
        "> **Ejercicio.** Generalice el resultado anterior a cualquier variable aleatoria $X$. ¿Debe $X$ cumplir ciertas condiciones o este resultado es incondicional?\n",
        ">>\n",
        ">> **Respuesta.** Sea $X$ una variable aleatoria. Demostremos que cuando $n$ crece, la distribución de cada media muestral, $\\overline{X_n}$, se encoge hacia el valor esperado de $X$.\n",
        ">>\n",
        ">> La varianza de una variable aleatoria mide la desviación cuadrática promedio de la variable con respecto a su media o, más exactamente, al valor esperado. Por lo tanto, para demostrar que cuando $n$ crece, la distribución de cada media muestral, $\\overline{X_n}$, se reduce hacia el valor esperado, basta con demostrar que la varianza disminuye y tiende a cero a medida que $n$ crece.\n",
        ">>\n",
        ">> Sea $\\sigma^2$ la varianza de $Y$. La varianza $V$ de la Media Muestral $\\overline{Y_n}$ es\n",
        ">>>\n",
        ">>> $V(\\overline{Y_n}) = V(\\frac{\\sum_{i = 1}^n Y_i}{n}) $\n",
        ">>>>\n",
        ">>>> $ = \\frac{1}{n^2}  \\sum_{i = 1}^n V(Y_i ) $\n",
        ">>>>\n",
        ">>>> $ = \\frac{1}{n^2}  \\sum_{i = 1}^n \\sigma^2 $\n",
        ">>>>\n",
        ">>>> $= \\frac{1}{n^2}  n \\sigma^2 $\n",
        ">>>>\n",
        ">>>> $ = \\frac{\\sigma^2}{n} \\rightarrow 0$\n",
        ">>>>\n",
        ">>  Esto es válido siempre que la varianza de $X$ sea finita. No se requieren otras condiciones. Esto refuerza la idea de que cuanto mayor sea el número de datos aleatorios, mejor será la evaluación del valor medio de cualquier variable aleatoria. ¡Qué sólido es este resultado! Es un ejemplo asombroso de lo que significa hacer ciencia cuando la aleatoriedad es el aire que respiramos.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "# GRADUACIÓN\n",
        "\n",
        "Elija uno de los dos proyectos siguientes:\n",
        ">\n",
        "> 1. Reformular el algoritmo científico para comparar lo que se piensa y lo que se observa, considerando la discrepancia resultante, que debe medirse en unidades apropiadas.\n",
        ">\n",
        "> 2. El programa `relativeFrequencyTendency2.py` dibuja la tendencia de la frecuencia relativa de caras al lanzar una moneda un número creciente de veces. Esta tendencia se presenta como una trayectoria que gira alrededor de la línea roja que apunta al valor esperado, `0.5`. Si repetimos el experimento, no se encontrará la misma trayectoria. Y si repetimos el experimento muchas veces, por cada número de lanzamientos o monedas, aparecerá una distribución. Desarrolle el código para una gráfica 3D realizable de dicha distribución, describa su modo de convergencia y compare sus resultados con las expectativas matemáticas.\n",
        "\n",
        "# CONCLUSIONES\n",
        "\n",
        "> **Ejercicio.** Exprese sus conclusiones personales.\n",
        "\n",
        ">> **Respuesta.** Nuestras conclusiones personales son:\n",
        "\n",
        "- Ha sido un placer trabajar con Python, Colab, Gemini, Codey y sus socios de IA.\n",
        "\n",
        "- El propósito del Método Científico es comparar lo que uno piensa con lo que observa.\n",
        "\n",
        "- El método científico para refinar lo que pensamos acerca de la naturaleza se basa en el sentido común:\n",
        "Si encontramos algo raro o extraño,\n",
        "se explica mejor desde un punto de vista diferente al nuestro.\n",
        "\"Explicar\" es un término que se utiliza para decir que\n",
        "algunos datos y las explicaciones ofrecidas\n",
        "parecen ser compatibles en buena medida.\n",
        "Esto no significa que\n",
        "la explicación sea la correcta ni la única entre los datos proporcionados.\n",
        "Pueden existir muchas teorías o explicaciones.\n",
        "Pero a medida que el campo de investigación madura,\n",
        "recopilando cada vez más datos en diferentes entornos,\n",
        "las posibles teorías compatibles tienden a disminuir.\n",
        "\n",
        "- Un grave problema en la Ciencia es que\n",
        "es raro ver eventos claramente definidos y deterministas.\n",
        "Más bien, siempre estamos rodeados de aleatoriedad\n",
        "que causa todo tipo de interferencias y fallos.\n",
        "Por eso nos planteamos la pregunta:\n",
        "¿Cómo podemos tomar decisiones cuando hay aleatoriedad?\n",
        "La respuesta, basada en el sentido común, es:\n",
        "Buscar tendencias. Si no existe ninguna, crear una.\n",
        "Ejemplos de tendencias:\n",
        "La frecuencia relativa tiende a una probabilidad\n",
        "cuando aumenta el número de ensayos.\n",
        "La media de una muestra tiende a la media de la población\n",
        "cuando la muestra es aleatoria y crece.\n",
        "Cuando aumenta el número de repeticiones,\n",
        "la distribución de que un evento distinguido\n",
        "aparezca k veces,\n",
        "tiende a un límite que coincide con la espectativa matemática.\n",
        "\n",
        "- Usando estas tendencias, podemos tomar decisiones.\n",
        "Pero, cuidado, las decisiones son personales y subjetivas.\n",
        "\n",
        "- Esto se ve claramente cuando se define la significancia,\n",
        "la proporción de eventos raros.\n",
        "El valor predeterminado es 0.05, y se aceptan valores inferiores,\n",
        "porque ser raro implica el derecho a formular nuevas hipótesis.\n",
        "\n",
        "- Por lo tanto, nos adherimos a la idea de que\n",
        "aceptar una teoría en la Ciencia no la convierte en verdad,\n",
        "sino que solo indica una compatibilidad entre\n",
        "datos y explicación, observación y teoría.\n",
        "\n",
        "\n",
        "- Hemos visto cómo funciona todo el mecanismo\n",
        "en la Distribución Binomial.\n",
        "\n",
        "- Esta noción es muy general.\n",
        "\n",
        "- La idea es recopilar muchos datos para estimar\n",
        "la distribución de la frecuencia relativa de,\n",
        "por ejemplo, cara,\n",
        "dada una hipótesis nula; por ejemplo,\n",
        "la probabilidad de cara es igual a la de cruz.\n",
        "\n",
        "- A continuación, utilizamos esa distribución para definir\n",
        "qué es normal, ordinario, y qué es anormal, extraordinario,\n",
        "según la hipótesis nula dada.\n",
        "Los eventos ordinarios son compatibles con la hipótesis nula\n",
        "e invitan a aceptarla;\n",
        "los eventos extraordinarios son incompatibles con la hipótesis nula e invitan a rechazarla.\n",
        "\n",
        "- El fundamento mismo de la ciencia en presencia de aleatoriedad es la existencia de distribuciones teóricas perfectamente definidas como el límite de las distribuciones observadas impulsadas por la aleatoriedad cuando el tamaño de la muestra crece hacia el infinito.\n",
        "\n",
        "- Contrariamente a la humildad del método científico, a los seres humanos nos encanta enamorarnos de teorías, dogmas, revelaciones e intuiciones.\n",
        "Por eso, merecemos ser llamados irracionales.\n",
        "Es por eso que la Ciencia real es un asunto irracional.\n",
        "\n",
        "# PARA SABER MÁS\n",
        "\n",
        "- Otras ideas como esta, del Autor, que cubren otros tópicos de la estadística:\n",
        "  https://www.ejristos.com/dl/javaevo5Pv3.zip\n",
        "\n",
        "- Aplicaciones a la vida ordinaria y a las Ciencias Sociales:\n",
        " https://www.ejristos.com/dl/EstVol1V18.pdf\n",
        "\n",
        "\n",
        "\n",
        "## ESCRIBA ALGO MEJOR QUE ESTO\n",
        "\n",
        "Modifique este material a su gusto hasta que logre algo que realmente lo satisfaga. Para ello, reutilice este material tanto como pueda bajando una versión editable.\n",
        "\n",
        "Este sistema de publicar se basa en los notebooks de JupyterLab, que permiten documentos que contienen células de texto, y células de código en Python que se ejecutan con un click.\n",
        "\n",
        "Todo es extremadamente fácil con Google Colab:\n",
        "\n",
        "## Google Colab\n",
        "\n",
        "\"Para Colab, simplemente puede visitar el notebook en el sitio web de Colab, https://colab.google/,  y hacer clic en \"Conectar\". La advertencia es que requiere una cuenta de Google activa. Luego, solo tiene que hacer clic en el botón \"Conectar\" en la esquina superior derecha y podrá comenzar a ejecutar el código aquí\".\n",
        "\n",
        "Visite el sitio https://colab.google/notebooks/ para encontrar maravillosos ejemplos de cuadernos escritos con esta tecnología. Esos cuadernos no son editables y se abren en modo lectura. El presente documento tiene versiones editables en https://ejristos.com . Dicha versión debe subirse a Colab, y si se abre en modo lectura, el modo edición se activa con doble click sobre el documento. Uno puede escribir texto o código, para ello debe elegir una celda correspondiente, cuyo menú se  encuentra en la barra horizontal y también al final de cada celda.\n",
        "\n",
        "El formateo se hace al terminar de escribir el documento. Para ello se usan comandos Markdown https://www.markdownguide.org/basic-syntax/. Son extremadamente simples y funcionan mal si uno usa muchos niveles de concatenación o con algunos símbolos en Latex. Use formateo simple y todo le irá bien.\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.12.3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}