Update app.py

app.py

@@ -26,57 +26,6 @@ def validate_inputs(A, B, C, AB, AC, BC, ABC, U):
     
     return errors
 
-def bayes_theorem(P_prior, P_likelihood, P_marginal):
-    return (P_likelihood * P_prior) / P_marginal
-
-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 (dinámico)
-    P_A_given_B_bayes = bayes_theorem(P_A, P_B_given_A, P_B)
-    P_B_given_A_bayes = bayes_theorem(P_B, P_A_given_B, P_A)
-    P_A_given_C_bayes = bayes_theorem(P_A, P_C_given_A, P_C)
-    P_C_given_A_bayes = bayes_theorem(P_C, P_A_given_C, P_A)
-    P_B_given_C_bayes = bayes_theorem(P_B, P_C_given_B, P_C)
-    P_C_given_B_bayes = bayes_theorem(P_C, P_B_given_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
     
@@ -90,57 +39,109 @@ def suggest_intersections(A, B, C, AB, AC, BC, ABC, U):
         "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
+        "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 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_BA / P_A if P_A > 0 else 0
+    PC_given_A = P_CA / P_A if P_A > 0 else 0
+    PC_given_B = P_CB / P_B if P_B > 0 else 0
 
-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)
+    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)
+    }
     
-    # Validar entradas
-    validation_errors = validate_inputs(A, B, C, AB, AC, BC, ABC, U)
-    if validation_errors:
-        return None, None, validation_errors
+    # Convert to DataFrame for better visualization
+    df = pd.DataFrame(list(formatted_probs.items()), columns=["Descripción", "Valor"])
+    return df
 
-    # Sugerir intersecciones
-    suggestions = suggest_intersections(A, B, C, AB, AC, BC, ABC, U)
+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
     
-    # Calcular probabilidades
-    probabilities = calculate_probabilities(A, B, C, AB, AC, BC, ABC, U)
+    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 venn_img, suggestions, probabilities
+    return  suggestions, probabilities_df, venn_image
 
-iface = gr.Interface(
-    fn=main, 
+# Gradio Interface
+interface = 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")
-    ], 
+        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.Image(type="pil"), 
-        gr.JSON(label="Sugerencias"), 
-        gr.JSON(label="Probabilidades")
+        gr.JSON(label="Sugerencias de Intersección"),
+        gr.Dataframe(label="Tabla de Probabilidades"),
+        gr.Image(type="pil", label="Diagrama de Venn")
     ],
-    live=True,  # Esta opción permite la actualización automática de resultados
-    title="Cálculo de Probabilidades y Diagramas 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__":
-    iface.launch()
+    interface.launch()