app.py

import gradio as gr
import matplotlib.pyplot as plt
from matplotlib_venn import venn3
from io import BytesIO
from PIL import Image
import pandas as pd

def validate_inputs(A, B, C, AB, AC, BC, ABC, U):
    union_ABC = A + B + C - AB - AC - BC + ABC
    errors = []
    
    if U < union_ABC:
        errors.append(f"El conjunto universal U ({U}) no puede ser menor que la unión de A, B, C ({union_ABC}).")
    if A < AB + AC - ABC:
        errors.append(f"A no puede ser menor que A∩B + A∩C - A∩B∩C: {AB + AC - ABC}")
    if B < AB + BC - ABC:
        errors.append(f"B no puede ser menor que A∩B + B∩C - A∩B∩C:  {AB + BC - ABC}")
    if C < AC + BC - ABC:
        errors.append(f"C no puede ser menor que A∩C + B∩C - A∩B∩C:  {AC + BC - ABC}")
    if ABC > AC:
        errors.append(f"A∩B∩C no puede ser mayor que A∩C:  {AC}")
    if ABC > AB:
        errors.append(f"A∩B∩C no puede ser mayor que A∩B:  {AC}")
    if ABC > BC:
        errors.append(f"A∩B∩C no puede ser mayor que B∩C:  {AC}")
    
    return errors

def calculate_probabilities(A, B, C, AB, AC, BC, ABC, U):
    # Probabilidades individuales
    P_A = A / U
    P_B = B / U
    P_C = C / U

    # Probabilidades condicionales
    P_A_given_B = AB / B
    P_B_given_A = AB / A
    P_A_given_C = AC / C
    P_C_given_A = AC / A
    P_B_given_C = BC / C
    P_C_given_B = BC / B

    # Probabilidad total para A, B y C
    P_A_total = P_B * P_A_given_B + P_C * P_A_given_C - P_B_given_C * P_C_given_B * P_A_given_B * P_A_given_C
    P_B_total = P_A * P_B_given_A + P_C * P_B_given_C - P_A_given_C * P_C_given_A * P_B_given_A * P_B_given_C
    P_C_total = P_A * P_C_given_A + P_B * P_C_given_B - P_A_given_B * P_B_given_A * P_C_given_A * P_C_given_B

    # Teorema de Bayes (probabilidad de A dado B, B dado A, etc.)
    P_A_given_B_bayes = (P_B_given_A * P_A) / P_B
    P_B_given_A_bayes = (P_A_given_B * P_B) / P_A
    P_A_given_C_bayes = (P_C_given_A * P_A) / P_C
    P_C_given_A_bayes = (P_A_given_C * P_C) / P_A
    P_B_given_C_bayes = (P_C_given_B * P_B) / P_C
    P_C_given_B_bayes = (P_B_given_C * P_C) / P_B

    return {
        "P(A)": P_A,
        "P(B)": P_B,
        "P(C)": P_C,
        "P(A|B)": P_A_given_B,
        "P(B|A)": P_B_given_A,
        "P(A|C)": P_A_given_C,
        "P(C|A)": P_C_given_A,
        "P(B|C)": P_B_given_C,
        "P(C|B)": P_C_given_B,
        "P(A) total": P_A_total,
        "P(B) total": P_B_total,
        "P(C) total": P_C_total,
        "P(A|B) Bayes": P_A_given_B_bayes,
        "P(B|A) Bayes": P_B_given_A_bayes,
        "P(A|C) Bayes": P_A_given_C_bayes,
        "P(C|A) Bayes": P_C_given_A_bayes,
        "P(B|C) Bayes": P_B_given_C_bayes,
        "P(C|B) Bayes": P_C_given_B_bayes
    }

def suggest_intersections(A, B, C, AB, AC, BC, ABC, U):
    union_ABC = A + B + C - AB - AC - BC + ABC
    
    max_AB = min(A, B, ABC)
    max_AC = min(A, C, ABC)
    max_BC = min(B, C, ABC)
    max_ABC = min(AB, AC, BC)

    suggestions = {
        "Mínimo valor sugerido para U": union_ABC,
        "Máximo valor sugerido para A ∩ B": max_AB,
        "Máximo valor sugerido para A ∩ C": max_AC,
        "Máximo valor sugerido para B ∩ C": max_BC,
        "Máximo valor sugerido para A ∩ B ∩ C": max_ABC
    }
    
    return suggestions

def plot_venn(A, B, C, AB, AC, BC, ABC):
    plt.figure(figsize=(8,8))
    venn = venn3(subsets = (A, B, AB, C, AC, BC, ABC), set_labels=('A', 'B', 'C'))
    buf = BytesIO()
    plt.savefig(buf, format='png')
    plt.close()
    buf.seek(0)
    return Image.open(buf)

def main(A, B, C, AB, AC, BC, ABC, U):
    # Mostrar gráfico de Venn
    venn_img = plot_venn(A, B, C, AB, AC, BC, ABC)
    
    # Validar entradas
    validation_errors = validate_inputs(A, B, C, AB, AC, BC, ABC, U)
    if validation_errors:
        return None, None, validation_errors

    # Sugerir intersecciones
    suggestions = suggest_intersections(A, B, C, AB, AC, BC, ABC, U)
    
    # Calcular probabilidades
    probabilities = calculate_probabilities(A, B, C, AB, AC, BC, ABC, U)
    
    return venn_img, suggestions, probabilities

iface = gr.Interface(
    fn=main, 
    inputs=[
        gr.Number(label="A"), 
        gr.Number(label="B"), 
        gr.Number(label="C"), 
        gr.Number(label="A ∩ B"), 
        gr.Number(label="A ∩ C"), 
        gr.Number(label="B ∩ C"), 
        gr.Number(label="A ∩ B ∩ C"), 
        gr.Number(label="U")
    ], 
    outputs=[
        gr.Image(type="pil"), 
        gr.JSON(label="Sugerencias"), 
        gr.JSON(label="Probabilidades")
    ],
    title="Cálculo de Probabilidades y Teorema de Bayes con Diagramas de Venn"
)

if __name__ == "__main__":
    iface.launch()