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 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 calculate_probabilities(A, B, C, AB, AC, BC, ABC, U):
    total = U if U > 0 else (A + B + C - AB - AC - BC + ABC)
    if total == 0:
        return {
            "P(A)": 0,
            "P(B)": 0,
            "P(C)": 0,
            "P(A ∩ B)": 0,
            "P(A ∩ C)": 0,
            "P(B ∩ C)": 0,
            "P(A ∩ B ∩ C)": 0,
        }

    P_A = A / total
    P_B = B / total
    P_C = C / total
    P_AB = AB / total
    P_AC = AC / total
    P_BC = BC / total
    P_ABC = ABC / total

    PA_given_B = P_AB / P_B if P_B > 0 else 0
    PA_given_C = P_AC / P_C if P_C > 0 else 0
    PB_given_C = P_BC / P_C if P_C > 0 else 0
    PB_given_A = P_AB / P_A if P_A > 0 else 0
    PC_given_A = P_AC / P_A if P_A > 0 else 0
    PC_given_B = P_BC / P_B if P_B > 0 else 0

    formatted_probs = {
        "P(A)": f"{P_A:.2%} ({A}/{total})",
        "P(B)": f"{P_B:.2%} ({B}/{total})",
        "P(C)": f"{P_C:.2%} ({C}/{total})",
        "P(A ∩ B)": f"{P_AB:.2%} ({AB}/{total})",
        "P(A ∩ C)": f"{P_AC:.2%} ({AC}/{total})",
        "P(B ∩ C)": f"{P_BC:.2%} ({BC}/{total})",
        "P(A ∩ B ∩ C)": f"{P_ABC:.2%} ({ABC}/{total})",
        "P(A | B)": f"{PA_given_B:.2%} (P(A ∩ B) / P(B)) = ({P_AB:.4f} / {P_B:.4f})",
        "P(A | C)": f"{PA_given_C:.2%} (P(A ∩ C) / P(C)) = ({P_AC:.4f} / {P_C:.4f})",
        "P(B | C)": f"{PB_given_C:.2%} (P(B ∩ C) / P(C)) = ({P_BC:.4f} / {P_C:.4f})",
        "P(B | A)": f"{PB_given_C:.2%} (P(B ∩ A) / P(A)) = ({P_BA:.4f} / {P_A:.4f})",
        "P(C | A)": f"{PC_given_A:.2%} (P(C ∩ A) / P(A)) = ({P_CA:.4f} / {P_A:.4f})",
        "P(C | B)": f"{PC_given_B:.2%} (P(C ∩ B) / P(B)) = ({P_CB:.4f} / {P_B:.4f})",
        "P(B | A)": f"{P_B_given_A_bayes:.2%} (Teorema de Bayes: P(A | B) * P(B) / P(A)) = ({P_A_given_B:.4f} * {P_B:.4f} / {P_A:.4f})",
        "P(A | B)": f"{P_A_given_B_bayes:.2%} (Teorema de Bayes: P(B | A) * P(A) / P(B)) = ({P_B_given_A:.4f} * {P_A:.4f} / {P_B:.4f})",
        "P(C | A)": f"{P_C_given_A_bayes:.2%} (Teorema de Bayes: P(A | C) * P(C) / P(A)) = ({P_A_given_C:.4f} * {P_C:.4f} / {P_A:.4f})",
        "P(A | C)": f"{P_A_given_C_bayes:.2%} (Teorema de Bayes: P(C | A) * P(A) / P(C)) = ({P_C_given_A:.4f} * {P_A:.4f} / {P_C:.4f})",
        "P(C | B)": f"{P_C_given_B_bayes:.2%} (Teorema de Bayes: P(B | C) * P(C) / P(B)) = ({P_B_given_C:.4f} * {P_C:.4f} / {P_B:.4f})",
        "P(B | C)": f"{P_B_given_C_bayes:.2%} (Teorema de Bayes: P(C | B) * P(B) / P(C)) = ({P_C_given_B:.4f} * {P_B:.4f} / {P_C:.4f})",

        "U (Universal Set)": total,
        "Complemento de A U B U C": U - (A + B + C - AB - AC - BC + ABC)
    }
    
    # Convert to DataFrame for better visualization
    df = pd.DataFrame(list(formatted_probs.items()), columns=["Descripción", "Valor"])
    return df

def draw_venn(A, B, C, AB, AC, BC, ABC):
    plt.figure(figsize=(10,10))
    venn = venn3(subsets=(max(0, A - AB - AC + ABC), max(0,B - AB - BC + ABC), max(0,AB - ABC), max(0,C- AC - BC + ABC), max(AC - ABC, 0), max(BC - ABC,0), ABC), set_labels=('A', 'B', 'C'))
    img = BytesIO()
    plt.savefig(img, format='png')
    img.seek(0)
    image = Image.open(img)
    return image

def main(U, A, B, C, AB, AC, BC, ABC):
    errors = validate_inputs(A, B, C, AB, AC, BC, ABC, U)
    if errors:
        return {"Errores de validación": errors}, None, None
    
    suggestions = suggest_intersections(A, B, C, AB, AC, BC, ABC, U)
    probabilities_df = calculate_probabilities(A, B, C, AB, AC, BC, ABC, U)
    venn_image = draw_venn(A, B, C, AB, AC, BC, ABC)
    
    return  suggestions, probabilities_df, venn_image

# Gradio Interface
interface = gr.Interface(
    fn=main,
    inputs=[
        gr.Number(label="U (Universal Set)"),
        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")
    ],
    outputs=[
        gr.JSON(label="Sugerencias de Intersección"),
        gr.Dataframe(label="Tabla de Probabilidades"),
        gr.Image(type="pil", label="Diagrama de Venn")
    ],
    title="Calculadora de Probabilidades y Diagrama de Venn",
    description="Calcula las probabilidades, intersecciones sugeridas y genera un diagrama de Venn.",
    live=True
)

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