Update my_pages/ica.py

my_pages/ica.py

@@ -5,83 +5,77 @@ import numpy as np
 def render():
     st.title("ICA Triangle")
 
-    # Initialize state
-    if "intentional" not in st.session_state:
-        st.session_state.intentional = 0.33
-        st.session_state.conventional = 0.33
-        st.session_state.arbitrary = 0.34
+    if "weights" not in st.session_state:
+        st.session_state.weights = {
+            "Intentional": 0.33,
+            "Conventional": 0.33,
+            "Arbitrary": 0.34
+        }
 
-    st.write("Adjust one slider at a time. The others will update automatically so the total = 1.")
-
-    # Choose which one to control
+    # Which one to adjust
     control_choice = st.radio(
-        "Which dimension do you want to adjust?",
+        "Select dimension to adjust",
         ["Intentional", "Conventional", "Arbitrary"],
         horizontal=True
     )
 
-    # Get current values
-    i = st.session_state.intentional
-    c = st.session_state.conventional
-    a = st.session_state.arbitrary
+    # Current values
+    w = st.session_state.weights
+    current_value = w[control_choice]
+
+    # Slider for selected one
+    new_value = st.slider(control_choice, 0.0, 1.0, current_value, 0.01)
+
+    # Adjust others proportionally
+    diff = new_value - current_value
+    others = [k for k in w.keys() if k != control_choice]
+    total_other = w[others[0]] + w[others[1]]
+
+    if total_other > 0:
+        w[others[0]] -= diff * (w[others[0]] / total_other)
+        w[others[1]] -= diff * (w[others[1]] / total_other)
 
-    if control_choice == "Intentional":
-        i = st.slider("Intentional", 0.0, 1.0, i, 0.01)
-        remaining = 1.0 - i
-        c = min(c, remaining)
-        a = remaining - c
-    elif control_choice == "Conventional":
-        c = st.slider("Conventional", 0.0, 1.0, c, 0.01)
-        remaining = 1.0 - c
-        i = min(i, remaining)
-        a = remaining - i
-    elif control_choice == "Arbitrary":
-        a = st.slider("Arbitrary", 0.0, 1.0, a, 0.01)
-        remaining = 1.0 - a
-        i = min(i, remaining)
-        c = remaining - i
+    w[control_choice] = new_value
 
-    # Save updated values
-    st.session_state.intentional = round(i, 4)
-    st.session_state.conventional = round(c, 4)
-    st.session_state.arbitrary = round(a, 4)
+    # Clamp small floating point errors
+    for k in w:
+        w[k] = max(0.0, min(1.0, round(w[k], 4)))
 
-    # Triangle vertices (equilateral)
+    # Normalize back to sum=1
+    total = sum(w.values())
+    if total != 0:
+        for k in w:
+            w[k] = round(w[k] / total, 4)
+
+    # Triangle vertices
     vertices = np.array([
         [0.5, np.sqrt(3)/2],  # Intentional
         [0, 0],               # Conventional
         [1, 0]                # Arbitrary
     ])
 
-    # Compute point position
+    # Point from barycentric coords
     point = (
-        st.session_state.intentional * vertices[0] +
-        st.session_state.conventional * vertices[1] +
-        st.session_state.arbitrary * vertices[2]
+        w["Intentional"] * vertices[0] +
+        w["Conventional"] * vertices[1] +
+        w["Arbitrary"] * vertices[2]
     )
 
     # Plot
     fig, ax = plt.subplots()
-    ax.plot(*np.append(vertices, [vertices[0]], axis=0).T, 'k-')  # Outline
+    ax.plot(*np.append(vertices, [vertices[0]], axis=0).T, 'k-')
     ax.scatter(vertices[:,0], vertices[:,1], c=["blue", "green", "red"], s=100)
     ax.text(*vertices[0], "Intentional", ha="center", va="bottom")
     ax.text(*vertices[1], "Conventional", ha="right", va="top")
     ax.text(*vertices[2], "Arbitrary", ha="left", va="top")
-
     ax.scatter(point[0], point[1], c="orange", s=200, zorder=5)
     ax.set_aspect("equal")
     ax.axis("off")
 
     st.pyplot(fig)
 
-    # Explanation
-    closest = max(
-        [("Intentional", st.session_state.intentional),
-         ("Conventional", st.session_state.conventional),
-         ("Arbitrary", st.session_state.arbitrary)],
-        key=lambda x: x[1]
-    )[0]
-
+    # Display interpretation
+    closest = max(w.items(), key=lambda x: x[1])[0]
     if closest == "Arbitrary":
         st.info("Example: Random seeds — a truly arbitrary decision.")
     elif closest == "Intentional":