Update app.py

app.py

@@ -1,6 +1,5 @@
 import gradio as gr
 import matplotlib.pyplot as plt
-from matplotlib.patches import Rectangle
 from matplotlib_venn import venn3
 from io import BytesIO
 from PIL import Image
@@ -20,7 +19,6 @@ def validate_inputs(A, B, C, AB, AC, BC, ABC, U):
 
 def calculate_probabilities(A, B, C, AB, AC, BC, ABC, U):
     total = U
-
     P_A = A / total
     P_B = B / total
     P_C = C / total
@@ -29,15 +27,6 @@ def calculate_probabilities(A, B, C, AB, AC, BC, ABC, U):
     P_BC = BC / total
     P_ABC = ABC / total
 
-    P_A_given_B = P_AB / P_B if P_B > 0 else 0
-    P_B_given_A = P_AB / P_A if P_A > 0 else 0
-    P_A_given_C = P_AC / P_C if P_C > 0 else 0
-    P_C_given_A = P_AC / P_A if P_A > 0 else 0
-    P_B_given_C = P_BC / P_C if P_C > 0 else 0
-    P_C_given_B = P_BC / P_B if P_B > 0 else 0
-
-    P_B_given_A_bayes = (P_A_given_B * P_B) / P_A if P_A > 0 else 0
-
     formatted_probs = {
         "P(A)": f"{P_A:.2%} ({A}/{total})",
         "P(B)": f"{P_B:.2%} ({B}/{total})",
@@ -45,26 +34,13 @@ def calculate_probabilities(A, B, C, AB, AC, BC, ABC, U):
         "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"{P_A_given_B:.2%}",
-        "P(B | A)": f"{P_B_given_A:.2%}",
-        "P(A | C)": f"{P_A_given_C:.2%}",
-        "P(C | A)": f"{P_C_given_A:.2%}",
-        "P(B | C)": f"{P_B_given_C:.2%}",
-        "P(C | B)": f"{P_C_given_B:.2%}",
-        "P(B | A) (Bayes)": f"{P_B_given_A_bayes:.2%}",
+        "P(A ∩ B ∩ C)": f"{P_ABC:.2%} ({ABC}/{total})"
     }
     
     return formatted_probs
 
 def plot_venn(A, B, C, AB, AC, BC, ABC, U):
     plt.figure(figsize=(8, 8))
-    
-    # Dibujar el conjunto universal como un rectángulo
-    ax = plt.gca()
-    ax.add_patch(Rectangle((0, 0), 1, 1, fill=None, edgecolor='black', linewidth=2))
-    
-    # Dibujar el diagrama de Venn
     subsets = {
         '100': A - AB - AC + ABC,
         '010': B - AB - BC + ABC,
@@ -75,15 +51,8 @@ def plot_venn(A, B, C, AB, AC, BC, ABC, U):
         '111': ABC
     }
     venn = venn3(subsets=subsets, set_labels=('A', 'B', 'C'))
-    
-    # Mostrar la cantidad fuera de A, B y C si no coincide con U
-    suma_subconjuntos = A + B + C - AB - AC - BC + ABC
-    if U > suma_subconjuntos:
-        faltante = U - suma_subconjuntos
-        plt.text(0.5, 0.9, f"Fuera de A, B y C: {faltante}", horizontalalignment='center', fontsize=12, bbox=dict(facecolor='white', alpha=0.5))
+    plt.title(f"Diagrama de Venn")
 
-    plt.title(f"Diagrama de Venn con U = {U}")
-    
     buf = BytesIO()
     plt.savefig(buf, format='png')
     buf.seek(0)
@@ -91,39 +60,17 @@ def plot_venn(A, B, C, AB, AC, BC, ABC, U):
     return img
 
 def suggest_intersections(A, B, C, AB, AC, BC, ABC, U):
-    # Ajuste de los valores sugeridos para que sean realistas y no negativos
-    max_AB = min(A, B, U - (A + B + C - AB - AC - BC + ABC))
-    max_AC = min(A, C, U - (A + B + C - AB - AC - BC + ABC))
-    max_BC = min(B, C, U - (A + B + C - AB - AC - BC + ABC))
+    # Generar sugerencias válidas y sin valores negativos
+    max_AB = min(A, B)
+    max_AC = min(A, C)
+    max_BC = min(B, C)
     max_ABC = min(max_AB, max_AC, max_BC)
-    
-    min_AB = max(0, A + B - U + C)
-    min_AC = max(0, A + C - U + B)
-    min_BC = max(0, B + C - U + A)
-    min_ABC = max(0, A + B + C - U)
-    
-    max_A = U - (B + C - BC)
-    max_B = U - (A + C - AC)
-    max_C = U - (A + B - AB)
-    min_A = max(AB + AC - ABC, 0)
-    min_B = max(AB + BC - ABC, 0)
-    min_C = max(AC + BC - ABC, 0)
 
     suggestions = {
-        "Máximo valor sugerido para A": max(0, max_A),
-        "Mínimo valor sugerido para A": max(0, min_A),
-        "Máximo valor sugerido para B": max(0, max_B),
-        "Mínimo valor sugerido para B": max(0, min_B),
-        "Máximo valor sugerido para C": max(0, max_C),
-        "Mínimo valor sugerido para C": max(0, min_C),
-        "Máximo valor sugerido para A ∩ B": max(0, max_AB),
-        "Mínimo valor sugerido para A ∩ B": max(0, min_AB),
-        "Máximo valor sugerido para A ∩ C": max(0, max_AC),
-        "Mínimo valor sugerido para A ∩ C": max(0, min_AC),
-        "Máximo valor sugerido para B ∩ C": max(0, max_BC),
-        "Mínimo valor sugerido para B ∩ C": max(0, min_BC),
-        "Máximo valor sugerido para A ∩ B ∩ C": max(0, max_ABC),
-        "Mínimo valor sugerido para A ∩ B ∩ C": max(0, min_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