Update app.py

app.py

@@ -46,98 +46,125 @@
 import streamlit as st
 import sympy as sp
 import pandas as pd
+from sympy.logic.boolalg import Xor
 
-# Page config
+# -----------------------
+# Page Setup
+# -----------------------
 st.set_page_config(page_title="AI Logic Solver", layout="centered")
 
-# Title
 st.title("🧩 AI Logic Solver")
-st.markdown("Solve logical expressions with **steps + truth table**")
+st.markdown("Solve logical expressions easily (with truth table)")
 
-# Instructions
-st.info("Use: ~ (NOT), & (AND), | (OR), >> (IMPLIES)")
-
-# Quick input buttons
-col1, col2, col3, col4 = st.columns(4)
+st.info("Use: ~ (NOT), & (AND), | (OR), >> (IMPLIES), ^ (XOR)")
 
+# -----------------------
+# Session State
+# -----------------------
 if "expr" not in st.session_state:
     st.session_state.expr = ""
 
-if col1.button("p"):
-    st.session_state.expr += "p"
-if col2.button("q"):
-    st.session_state.expr += "q"
-if col3.button("r"):
-    st.session_state.expr += "r"
-if col4.button("Clear"):
-    st.session_state.expr = ""
-
-col5, col6, col7, col8 = st.columns(4)
-
-if col5.button("~"):
-    st.session_state.expr += "~"
-if col6.button("&"):
-    st.session_state.expr += " & "
-if col7.button("|"):
-    st.session_state.expr += " | "
-if col8.button(">>"):
-    st.session_state.expr += " >> "
+# -----------------------
+# BUTTON FUNCTIONS
+# -----------------------
+def add(val):
+    st.session_state.expr += val
 
-# Input box
-expr_input = st.text_input("Enter expression:", value=st.session_state.expr)
+def clear():
+    st.session_state.expr = ""
 
-# Process
+def backspace():
+    st.session_state.expr = st.session_state.expr[:-1]
+
+# -----------------------
+# SIMPLE BUTTON UI
+# -----------------------
+st.subheader("🔘 Build Expression")
+
+col1, col2, col3 = st.columns(3)
+
+with col1:
+    if st.button("p"):
+        add("p")
+    if st.button("q"):
+        add("q")
+    if st.button("r"):
+        add("r")
+
+with col2:
+    if st.button("AND (&)"):
+        add(" & ")
+    if st.button("OR (|)"):
+        add(" | ")
+    if st.button("NOT (~)"):
+        add("~")
+
+with col3:
+    if st.button("IMPLIES (>>)"):
+        add(" >> ")
+    if st.button("XOR (^)"):
+        add(" ^ ")
+    if st.button("( )"):
+        add("()")
+
+# Extra controls
+col4, col5 = st.columns(2)
+with col4:
+    if st.button("⬅ Backspace"):
+        backspace()
+with col5:
+    if st.button("🗑 Clear"):
+        clear()
+
+# -----------------------
+# INPUT BOX
+# -----------------------
+expr_input = st.text_input("✏️ Your Expression:", value=st.session_state.expr)
+
+# -----------------------
+# PROCESSING
+# -----------------------
 if expr_input:
     try:
-        # Define symbols
-        p, q, r = sp.symbols('p q r')
+        # Clean input
+        expr_clean = expr_input.strip()
 
-        # Convert expression
-        expr = sp.sympify(expr_input)
+        # Check parentheses
+        if expr_clean.count("(") != expr_clean.count(")"):
+            st.warning("⚠️ Unbalanced parentheses!")
 
-        st.success("✅ Expression parsed successfully!")
+        # Replace XOR
+        expr_clean = expr_clean.replace("^", "Xor")
 
-        # =========================
-        # STEP-BY-STEP (Basic)
-        # =========================
-        st.subheader("🧠 Step-by-Step Simplification")
-
-        steps = []
+        # Define symbols
+        p, q, r = sp.symbols('p q r')
 
-        # Step 1: Original
-        steps.append(f"Original: {expr}")
+        # Parse expression
+        expr = sp.sympify(expr_clean, locals={"Xor": Xor})
 
-        # Step 2: Remove implication
-        expr_no_impl = expr.replace(
-            lambda x: isinstance(x, sp.Implies),
-            lambda x: ~x.args[0] | x.args[1]
-        )
-        steps.append(f"Remove implication: {expr_no_impl}")
+        st.success("✅ Expression is valid!")
 
-        # Step 3: Simplify
-        simplified = sp.simplify_logic(expr_no_impl)
-        steps.append(f"Simplified: {simplified}")
+        # -----------------------
+        # SIMPLIFY
+        # -----------------------
+        simplified = sp.simplify_logic(expr)
 
-        for step in steps:
-            st.write("➡️", step)
-
-        # Final simplified
-        st.subheader("📌 Final Simplified Expression:")
+        st.subheader("📌 Simplified Expression:")
         st.write(simplified)
 
-        # =========================
+        # -----------------------
         # TRUTH TABLE
-        # =========================
+        # -----------------------
         st.subheader("📊 Truth Table")
 
         variables = sorted(expr.free_symbols, key=lambda x: str(x))
         rows = []
 
         for values in range(2**len(variables)):
-            combination = list(map(int, bin(values)[2:].zfill(len(variables))))
-            subs = dict(zip(variables, combination))
+            combo = list(map(int, bin(values)[2:].zfill(len(variables))))
+            subs = dict(zip(variables, combo))
 
-            result = bool(expr.subs(subs))  # ✅ FIXED
+            result = bool(expr.subs(subs))  # stable
 
             row = {str(var): val for var, val in subs.items()}
             row["Result"] = int(result)
@@ -148,12 +175,20 @@ if expr_input:
 
         # Download option
         st.download_button(
-            "📥 Download Truth Table",
+            "📥 Download CSV",
             df.to_csv(index=False),
             file_name="truth_table.csv",
             mime="text/csv"
         )
 
     except Exception as e:
-        st.error(f"❌ Invalid expression: {str(e)}")
-        st.info("💡 Example: ~(p & q) >> r")
+        st.error("❌ Invalid expression!")
+
+        st.write("🔍 Error detail:")
+        st.code(str(e))
+
+        st.info("💡 Try examples:")
+        st.code("~(p & q) >> r")
+        st.code("p | q")
+        st.code("p ^ q")
+        st.code("(p & q) | (r)")