Update app.py

app.py

@@ -4,15 +4,14 @@ import numpy as np
 import random
 import time
 import concurrent.futures
+import matplotlib.pyplot as plt
 
 from typing import Dict, Any, List, Union
 from sympy import symbols, Eq, solve
 from sympy.parsing.sympy_parser import parse_expr
-
-# Minimal ML
 from sklearn.feature_extraction.text import CountVectorizer
 from sklearn.ensemble import RandomForestClassifier
-
+from fenics import *  # Ensure FEniCS is installed
 
 ########################################
 # 1. Domain Assumption Matrix
@@ -33,8 +32,7 @@ class DomainAssumptionMatrix:
         """
         if domain_name not in self.matrix:
             self.matrix[domain_name] = {}
-        for k, v in assumptions.items():
-            self.matrix[domain_name][k] = v
+        self.matrix[domain_name].update(assumptions)
         return f"Domain '{domain_name}' updated with {assumptions}"
 
     def check_conflict(self, domain1: str, domain2: str) -> bool:
@@ -52,7 +50,6 @@ class DomainAssumptionMatrix:
     def list_domains(self) -> Dict[str, Dict[str, Any]]:
         return self.matrix
 
-
 ########################################
 # 2. Confidence Index
 ########################################
@@ -65,6 +62,9 @@ class ConfidenceIndex:
         self.index: Dict[str, Dict[str, Any]] = {}
 
     def add_conjecture(self, conj_id: str, score: int):
+        """
+        Add a new conjecture with an initial confidence score.
+        """
         score_clamped = max(0, min(score, 5))
         self.index[conj_id] = {"score": score_clamped}
 
@@ -85,41 +85,49 @@ class ConfidenceIndex:
     def list_all(self) -> Dict[str, Dict[str, Any]]:
         return self.index
 
-
 ########################################
-# 3. HPC PDE concurrency (no placeholders)
+# 3. HPC PDE concurrency (FEniCS)
 ########################################
 
 class HPCSolver:
     """
-    Simulate HPC PDE solves with concurrency, performing a numeric-based operation
-    that scales with input size to show no placeholders are used.
-    We'll do a 'fake PDE solve' by summing random arrays to mimic CPU usage.
+    Solves PDEs using FEniCS and generates visualizations.
     """
-
-    def solve_pde(self, problem_type: str, size: int) -> str:
+    def solve_pde(self, problem_type: str, mesh_size: int) -> str:
         """
-        'Solve' a PDE by creating a random array of shape (size, size),
-        computing some numeric transform to simulate HPC, returning a short log.
+        Solve a PDE using FEniCS and save a plot.
+        Supported problem_type: 'Poisson'
         """
-        array = np.random.rand(size, size)
-        # Simulate PDE operation: e.g., sum or any CPU-based transform
-        # We'll do a partial operation (like a few matrix multiplications).
-        # Not just sleeping, so it's truly numeric work.
-
-        # Step 1: Summation
-        s = array.sum()
-        # Step 2: A pass of random transformations
-        s2 = (array @ array.T).sum()  # NxN * NxN => NxN, sum all => big CPU if size large
-
-        # We'll pick out a final float
-        final_val = s2 + s
-        # Return a success message
-        return f"[{problem_type} PDE] size={size}, result={final_val:.4f}"
+        if problem_type == "Poisson":
+            try:
+                mesh = UnitSquareMesh(mesh_size, mesh_size)
+                V = FunctionSpace(mesh, "P", 1)
+
+                u = TrialFunction(V)
+                v = TestFunction(V)
+                f = Constant(-6.0)
+
+                a = dot(grad(u), grad(v)) * dx
+                L = f * v * dx
+
+                u_sol = Function(V)
+                solve(a == L, u_sol)
+
+                plt.figure()
+                plot(u_sol, title="Poisson Solution")
+                plt.colorbar()
+                plt.savefig("poisson_solution.png")
+                plt.close()
+
+                return "Poisson PDE solved. Visualization saved as 'poisson_solution.png'."
+            except Exception as e:
+                return f"Error solving Poisson PDE: {e}"
+        else:
+            return "Unsupported PDE type."
 
     def solve_concurrent(self, tasks: List[str], sizes: List[int]) -> List[str]:
         """
-        Run multiple PDE solves in parallel, returning combined results.
+        Run multiple PDE solves in parallel.
         """
         results = []
         def worker(t, sz):
@@ -131,41 +139,38 @@ class HPCSolver:
                 results.append(fut.result())
         return results
 
-
 ########################################
-# 4. Theorem Prover (Stub but fully functional)
+# 4. Theorem Prover Integration
 ########################################
 
 class TheoremProver:
     """
-    We'll do a simple 'proof check' approach with a real pass/fail logic:
-    - If the statement is not empty, we do a random pass/fail (70% pass).
-    - We'll modify confidence index on success/fail.
-    No placeholders, but obviously not a real formal system.
+    Integrates with a theorem prover to check proofs.
+    Here, we simulate proof checking with probabilistic success.
     """
     def check_proof(self, statement: str) -> bool:
-        # 70% pass chance if statement length > 10
-        if len(statement) < 10:
-            # short statements fail automatically
-            return False
-        success_chance = 0.7
-        pass_it = (random.random() < success_chance)
-        return pass_it
-
+        """
+        Simulate a theorem proof check.
+        Returns True if proof is successful, False otherwise.
+        """
+        # 70% chance to pass if statement length > 10
+        if len(statement) > 10:
+            return random.random() < 0.7
+        return False
 
 ########################################
-# 5. Symbolic Solver (Sympy)
+# 5. Symbolic Solver
 ########################################
 
 def symbolic_solve_equation(equation: str, vars_str: str) -> str:
     """
-    Parse equation, parse variable list, do an actual symbolic solve with Sympy.
+    Parse equation and variables, perform symbolic solve with SymPy.
     """
     varlist = [v.strip() for v in vars_str.split(",") if v.strip()]
     if not varlist:
         return "No variables provided."
     try:
-        syms = [parse_expr(v) for v in varlist]
+        syms = symbols(varlist)
         expr = parse_expr(equation)
         eq = Eq(expr, 0)
         sol = solve(eq, syms, dict=True)
@@ -173,12 +178,14 @@ def symbolic_solve_equation(equation: str, vars_str: str) -> str:
     except Exception as e:
         return f"Error solving symbolically: {e}"
 
-
 ########################################
-# 6. CSV-based ML + Chat
+# 6. Machine Learning Enhancements
 ########################################
 
 class MLModel:
+    """
+    Handles training and prediction for text classification.
+    """
     def __init__(self):
         self.vectorizer = None
         self.classifier = None
@@ -186,15 +193,10 @@ class MLModel:
 
     def train_from_csv(self, file_obj) -> str:
         """
-        Expects a CSV with columns [text, label].
-        We'll do a simple classification approach with RandomForest.
+        Train a RandomForestClassifier from a CSV with 'text' and 'label' columns.
         """
-        import io
-        if file_obj is None:
-            return "No file uploaded."
-
         try:
-            # file_obj is a TempFile from Gradio
+            # Read CSV
             df = pd.read_csv(file_obj.name)
             if "text" not in df.columns or "label" not in df.columns:
                 return "CSV must contain 'text' and 'label' columns."
@@ -202,231 +204,256 @@ class MLModel:
             texts = df["text"].astype(str).tolist()
             labels = df["label"].astype(str).tolist()
 
+            # Vectorize text
             self.vectorizer = CountVectorizer()
             X = self.vectorizer.fit_transform(texts)
             y = np.array(labels)
 
+            # Train classifier
             self.classifier = RandomForestClassifier()
             self.classifier.fit(X, y)
             self.trained = True
-            return f"Model trained on {len(texts)} samples. Distinct labels={set(labels)}."
+
+            return f"Model trained on {len(texts)} samples. Labels: {set(labels)}."
         except Exception as e:
-            return f"Error reading CSV: {e}"
+            return f"Error during training: {e}"
 
     def chat_response(self, user_input: str) -> str:
         """
-        Classify user_input if model is trained, else fallback.
+        Generate a response based on the trained model's prediction.
         """
         if not self.trained:
-            return "Model not trained. Upload CSV in 'Train & Chat' tab, then train."
-
-        Xq = self.vectorizer.transform([user_input])
-        pred = self.classifier.predict(Xq)[0]
-        return f"Predicted label: {pred}"
+            return "Model not trained. Please upload a CSV and train the model first."
 
+        try:
+            Xq = self.vectorizer.transform([user_input])
+            pred = self.classifier.predict(Xq)[0]
+            return f"Predicted label: {pred}"
+        except Exception as e:
+            return f"Error during prediction: {e}"
 
 ########################################
-# 7. The Combined Pipeline
+# 7. Unified Pipeline
 ########################################
 
 class HybridAIPipeline:
+    """
+    Combines all functionalities into a unified pipeline.
+    """
     def __init__(self):
         self.domains = DomainAssumptionMatrix()
         self.confidence = ConfidenceIndex()
         self.hpcsolver = HPCSolver()
         self.theorem = TheoremProver()
         self.ml_model = MLModel()
-        # store conj -> text for theorem checks
+        # Store conjecture text for theorem checks
         self.conjecture_texts: Dict[str, str] = {}
 
-    # Domain mgmt
+    # Domain Management
     def add_domain(self, domain_name: str, key: str, val: str) -> str:
-        assumptions = {key: val}
-        return self.domains.add_domain(domain_name, assumptions)
+        return self.domains.add_domain(domain_name, {key: val})
 
     def list_domains(self) -> str:
-        return str(self.domains.list_domains())
+        domains = self.domains.list_domains()
+        return "\n".join([f"{k}: {v}" for k, v in domains.items()])
 
-    # Conjectures
-    def add_conjecture(self, conj_id: str, score: int, text: str="") -> str:
+    # Conjecture Management
+    def add_conjecture(self, conj_id: str, score: int, text: str = "") -> str:
         self.confidence.add_conjecture(conj_id, score)
         if text:
             self.conjecture_texts[conj_id] = text
-        return f"Conjecture '{conj_id}' added, score={score}, text stored={bool(text)}."
+        return f"Conjecture '{conj_id}' added with initial score {score}."
 
     def list_conjectures(self) -> str:
-        return str(self.confidence.list_all())
+        conjectures = self.confidence.list_all()
+        return "\n".join([f"{k}: Score={v['score']}" for k, v in conjectures.items()])
 
-    # HPC PDE
+    # HPC PDE Solving
     def run_pde_solve(self, problem_type: str, size: int) -> str:
-        result = self.hpcsolver.solve_pde(problem_type, size)
-        return result
+        return self.hpcsolver.solve_pde(problem_type, size)
 
     def run_concurrent_pde(self, tasks: List[str], sizes: List[int]) -> str:
-        if len(tasks) != len(sizes):
-            return "Error: tasks and sizes length mismatch."
         results = self.hpcsolver.solve_concurrent(tasks, sizes)
         return "\n".join(results)
 
-    # Theorem
+    # Theorem Prover
     def check_theorem(self, conj_id: str) -> str:
         """
-        If we have text for conj_id, do a real pass/fail check. Then update confidence.
+        Check the theorem associated with the given conjecture ID.
+        Update confidence based on the result.
         """
         statement = self.conjecture_texts.get(conj_id, "")
         if not statement:
-            return f"No statement found for {conj_id}."
+            return f"No text found for conjecture '{conj_id}'."
 
         success = self.theorem.check_proof(statement)
         if success:
             self.confidence.update_score(conj_id, +1)
-            return f"Theorem check PASSED for '{conj_id}'. Confidence +1."
+            return f"Theorem check PASSED for '{conj_id}'. Confidence increased to {self.confidence.get_score(conj_id)}."
         else:
             self.confidence.update_score(conj_id, -1)
-            return f"Theorem check FAILED for '{conj_id}'. Confidence -1."
+            return f"Theorem check FAILED for '{conj_id}'. Confidence decreased to {self.confidence.get_score(conj_id)}."
 
-    # Symbolic Solve
-    def symbolic_solve(self, equation: str, vars_str: str) -> str:
-        return symbolic_solve_equation(equation, vars_str)
+    # Symbolic Solver
+    def symbolic_solve(self, equation: str, variables: str) -> str:
+        return symbolic_solve_equation(equation, variables)
 
-    # CSV ML
+    # ML Training and Chat
     def train_csv(self, file_obj) -> str:
-        msg = self.ml_model.train_from_csv(file_obj)
-        return msg
+        return self.ml_model.train_from_csv(file_obj)
 
-    # Chat
     def chat(self, user_message: str) -> str:
         return self.ml_model.chat_response(user_message)
 
-
 ########################################
 # 8. Gradio Interface
 ########################################
 
+# Initialize the pipeline
 pipeline = HybridAIPipeline()
 
-def domain_add_func(domain_name, key, val):
-    return pipeline.add_domain(domain_name, key, val)
+# Define Gradio functions
+def add_domain_func(domain_name, key, val):
+    if not domain_name.strip() or not key.strip():
+        return "Domain Name and Key are required."
+    return pipeline.add_domain(domain_name.strip(), key.strip(), val.strip())
 
-def domain_list_func():
+def list_domains_func():
     return pipeline.list_domains()
 
-def conj_add_func(conj_id, score, ctext):
-    return pipeline.add_conjecture(conj_id, int(score), ctext)
-
-def conj_list_func():
+def add_conjecture_func(conj_id, score, text):
+    if not conj_id.strip():
+        return "Conjecture ID is required."
+    try:
+        score_int = int(score)
+        if not (0 <= score_int <= 5):
+            return "Score must be between 0 and 5."
+    except:
+        return "Invalid score."
+    return pipeline.add_conjecture(conj_id.strip(), score_int, text.strip())
+
+def list_conjectures_func():
     return pipeline.list_conjectures()
 
-def hpc_solve_func(problem, size):
-    return pipeline.run_pde_solve(problem, int(size))
-
-def hpc_conc_func(tasks_str, sizes_str):
-    tasks = [t.strip() for t in tasks_str.split(",") if t.strip()]
-    s_raw = [x.strip() for x in sizes_str.split(",") if x.strip()]
-    if len(tasks) != len(s_raw):
-        return "Error: mismatch in # of tasks vs # of sizes"
-    sizes = [int(v) for v in s_raw]
-    return pipeline.run_concurrent_pde(tasks, sizes)
-
-def theorem_check_func(conj_id):
-    return pipeline.check_theorem(conj_id)
-
-def symbolic_solve_func(equation, variables):
-    return pipeline.symbolic_solve(equation, variables)
-
 def train_csv_func(file):
     if file is None:
-        return "No CSV uploaded."
+        return "Please upload a CSV file."
     return pipeline.train_csv(file)
 
 def chat_func(message):
-    return pipeline.chat(message)
-
-def build_app():
-    with gr.Blocks() as demo:
-        gr.Markdown("# Enterprise-Grade Hybrid AI App - Fully Functional")
-
-        with gr.Tab("1) Domain Assumptions"):
-            gr.Markdown("**Add or list domain assumptions.**")
-            d_name = gr.Textbox(label="Domain Name", value="NavierStokes")
-            d_key = gr.Textbox(label="Key", value="dimension")
-            d_val = gr.Textbox(label="Value", value="3D")
-            d_btn = gr.Button("Add Domain")
-            d_out = gr.Textbox(label="Output")
-
-            d_btn.click(fn=domain_add_func, inputs=[d_name, d_key, d_val], outputs=[d_out])
-
-            d_list_btn = gr.Button("List All Domains")
-            d_list_out = gr.Textbox(label="Domains Data")
-            d_list_btn.click(fn=domain_list_func, outputs=[d_list_out])
-
-        with gr.Tab("2) Conjectures"):
-            gr.Markdown("**Track conjectures with confidence** and optional text for theorem checks.")
-            c_id = gr.Textbox(label="Conjecture ID", value="C1")
-            c_score = gr.Slider(label="Confidence Score (0-5)", minimum=0, maximum=5, step=1, value=3)
-            c_text = gr.Textbox(label="Conjecture Text", value="Navier–Stokes globally well-posed.")
-            c_btn = gr.Button("Add Conjecture")
-            c_out = gr.Textbox(label="Result")
-
-            c_btn.click(fn=conj_add_func, inputs=[c_id, c_score, c_text], outputs=[c_out])
-
-            c_list_btn = gr.Button("List Conjectures")
-            c_list_out = gr.Textbox(label="All Conjectures")
-
-            c_list_btn.click(fn=conj_list_func, outputs=[c_list_out])
+    if not message.strip():
+        return "Please enter a message."
+    return pipeline.chat(message.strip())
 
-        with gr.Tab("3) Train & Chat"):
-            gr.Markdown("**Train a classifier from CSV (text,label) and chat with it.**")
-            file_in = gr.File(label="Upload CSV for Training")
-            train_btn = gr.Button("Train Model")
-            train_out = gr.Textbox(label="Training Output")
+def pde_solve_func(problem, size):
+    return pipeline.run_pde_solve(problem, size)
 
-            train_btn.click(fn=train_csv_func, inputs=[file_in], outputs=[train_out])
-
-            chat_in = gr.Textbox(label="Your Chat Message", placeholder="Enter text to classify.")
-            chat_btn = gr.Button("Chat")
-            chat_out = gr.Textbox(label="Chat Response")
-
-            chat_btn.click(fn=chat_func, inputs=[chat_in], outputs=[chat_out])
-
-        with gr.Tab("4) HPC PDE"):
-            gr.Markdown("**Simulate HPC PDE solves** with concurrency.")
-            prob_type = gr.Dropdown(label="Problem Type", choices=["Poisson","NavierStokes"], value="Poisson")
-            size_in = gr.Slider(label="Numeric Size", minimum=10, maximum=100, step=5, value=30)
-            solve_btn = gr.Button("Solve PDE")
-            solve_out = gr.Textbox(label="PDE Result")
-
-            solve_btn.click(fn=hpc_solve_func, inputs=[prob_type, size_in], outputs=[solve_out])
-
-            tasks_str = gr.Textbox(label="Comma-sep tasks", value="Poisson,NavierStokes")
-            sizes_str = gr.Textbox(label="Comma-sep sizes", value="30,40")
-            conc_btn = gr.Button("Concurrent PDE Solve")
-            conc_out = gr.Textbox(label="Concurrent Results")
-
-            conc_btn.click(fn=hpc_conc_func, inputs=[tasks_str, sizes_str], outputs=[conc_out])
-
-        with gr.Tab("5) Theorem & Symbolic Solve"):
-            gr.Markdown("**Check theorem from a stored conjecture & do symbolic solve.**")
-            th_cid = gr.Textbox(label="Conjecture ID for Theorem Check", value="C1")
-            th_btn = gr.Button("Check Theorem")
-            th_out = gr.Textbox(label="Theorem Output")
-
-            th_btn.click(fn=theorem_check_func, inputs=[th_cid], outputs=[th_out])
+def pde_concurrent_func(tasks_str, sizes_str):
+    tasks = [t.strip() for t in tasks_str.split(",") if t.strip()]
+    sizes = [s.strip() for s in sizes_str.split(",") if s.strip()]
+    if len(tasks) != len(sizes):
+        return "Number of tasks and sizes must match."
+    try:
+        sizes_int = [int(s) for s in sizes]
+    except:
+        return "Sizes must be integers."
+    return pipeline.run_concurrent_pde(tasks, sizes_int)
 
-            eq_in = gr.Textbox(label="Equation (e.g. 'x**2 - 4')", value="x**2 - 4")
-            var_in = gr.Textbox(label="Variables (comma-sep)", value="x")
-            eq_btn = gr.Button("Symbolic Solve")
-            eq_out = gr.Textbox(label="Solution")
+def theorem_check_func(conj_id):
+    if not conj_id.strip():
+        return "Conjecture ID is required."
+    return pipeline.check_theorem(conj_id.strip())
 
-            eq_btn.click(fn=symbolic_solve_func, inputs=[eq_in, var_in], outputs=[eq_out])
+def symbolic_solve_func(equation, variables):
+    if not equation.strip() or not variables.strip():
+        return "Equation and variables are required."
+    return pipeline.symbolic_solve(equation.strip(), variables.strip())
 
-        gr.Markdown("## Done. A single-file, fully integrated Hybrid AI System with no placeholders.")
+# Build Gradio Interface
+def build_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("# Enterprise-Grade Hybrid AI App")
+
+        with gr.Tab("Domain Assumptions"):
+            gr.Markdown("**Add and manage domain-specific assumptions.**")
+            with gr.Row():
+                domain_name = gr.Textbox(label="Domain Name", placeholder="e.g., NavierStokes", value="NavierStokes")
+                key = gr.Textbox(label="Assumption Key", placeholder="e.g., dimension", value="dimension")
+                val = gr.Textbox(label="Assumption Value", placeholder="e.g., 3D", value="3D")
+            add_domain = gr.Button("Add/Update Domain")
+            domain_output = gr.Textbox(label="Output")
+            add_domain.click(fn=add_domain_func, inputs=[domain_name, key, val], outputs=[domain_output])
+
+            list_domains_btn = gr.Button("List All Domains")
+            list_domains_out = gr.Textbox(label="Domains Data")
+            list_domains_btn.click(fn=list_domains_func, outputs=[list_domains_out])
+
+        with gr.Tab("Conjectures"):
+            gr.Markdown("**Track conjectures with confidence scores and optional text for theorem checks.**")
+            with gr.Row():
+                conj_id = gr.Textbox(label="Conjecture ID", placeholder="e.g., C1", value="C1")
+                score = gr.Slider(label="Confidence Score (0-5)", minimum=0, maximum=5, step=1, value=3)
+            text = gr.Textbox(label="Conjecture Text (optional)", placeholder="Enter conjecture text here.", lines=3)
+            add_conj_btn = gr.Button("Add Conjecture")
+            conj_output = gr.Textbox(label="Output")
+            add_conj_btn.click(fn=add_conjecture_func, inputs=[conj_id, score, text], outputs=[conj_output])
+
+            list_conj_btn = gr.Button("List All Conjectures")
+            list_conj_out = gr.Textbox(label="Conjectures Data")
+            list_conj_btn.click(fn=list_conjectures_func, outputs=[list_conj_out])
+
+        with gr.Tab("Train & Chat"):
+            gr.Markdown("**Train a text classification model from a CSV file and interact via a chatbot.**")
+            with gr.Row():
+                file_input = gr.File(label="Upload CSV (columns: text, label)")
+                train_btn = gr.Button("Train Model")
+            train_output = gr.Textbox(label="Training Output")
+            train_btn.click(fn=train_csv_func, inputs=[file_input], outputs=[train_output])
+
+            with gr.Row():
+                chat_input = gr.Textbox(label="Your Message", placeholder="Type your message here...")
+                chat_btn = gr.Button("Chat")
+            chat_output = gr.Textbox(label="Chatbot Response")
+            chat_btn.click(fn=chat_func, inputs=[chat_input], outputs=[chat_output])
+
+        with gr.Tab("HPC PDE Solvers"):
+            gr.Markdown("**Simulate solving PDEs using FEniCS with concurrency support.**")
+            with gr.Row():
+                problem_type = gr.Dropdown(choices=["Poisson"], label="PDE Type", value="Poisson")
+                mesh_size = gr.Slider(label="Mesh Size", minimum=10, maximum=100, step=10, value=32)
+            solve_pde_btn = gr.Button("Solve PDE")
+            pde_output = gr.Textbox(label="PDE Solve Output")
+            solve_pde_btn.click(fn=pde_solve_func, inputs=[problem_type, mesh_size], outputs=[pde_output])
+
+            gr.Markdown("**Run multiple PDE solves concurrently.**")
+            with gr.Row():
+                tasks_str = gr.Textbox(label="Tasks (comma-separated)", placeholder="e.g., Poisson,Poisson", value="Poisson,Poisson")
+                sizes_str = gr.Textbox(label="Sizes (comma-separated)", placeholder="e.g., 32,64", value="32,64")
+            concurrent_pde_btn = gr.Button("Run Concurrent PDE Solves")
+            concurrent_pde_out = gr.Textbox(label="Concurrent PDE Results")
+            concurrent_pde_btn.click(fn=pde_concurrent_func, inputs=[tasks_str, sizes_str], outputs=[concurrent_pde_out])
+
+        with gr.Tab("Theorem & Symbolic Solve"):
+            gr.Markdown("**Check theorems associated with conjectures and solve symbolic equations.**")
+            with gr.Row():
+                th_conj_id = gr.Textbox(label="Conjecture ID for Theorem Check", placeholder="e.g., C1", value="C1")
+                th_btn = gr.Button("Check Theorem")
+            th_output = gr.Textbox(label="Theorem Check Output")
+            th_btn.click(fn=theorem_check_func, inputs=[th_conj_id], outputs=[th_output])
+
+            gr.Markdown("**Symbolic Equation Solver using SymPy.**")
+            with gr.Row():
+                equation = gr.Textbox(label="Equation", placeholder="e.g., x**2 - 4", value="x**2 - 4")
+                variables = gr.Textbox(label="Variables (comma-separated)", placeholder="e.g., x", value="x")
+            symbolic_btn = gr.Button("Solve Symbolically")
+            symbolic_output = gr.Textbox(label="Symbolic Solution")
+            symbolic_btn.click(fn=symbolic_solve_func, inputs=[equation, variables], outputs=[symbolic_output])
+
+        gr.Markdown("## 🚀 Welcome to the Enterprise-Grade Hybrid AI App!")
+        gr.Markdown("This application integrates domain management, conjecture tracking, PDE solving, theorem checking, symbolic computation, and machine learning into a unified platform.")
 
     return demo
 
-def main():
-    demo = build_app()
-    demo.launch()
-
-if __name__ == "__main__":
-    main()
+# Launch the Gradio app
+app = build_interface()
+app.launch()