Update app.py

app.py

@@ -1,78 +1,79 @@
-import dolfinx
-from dolfinx import mesh, fem
-from mpi4py import MPI
-import numpy as np
 import gradio as gr
 import pandas as pd
+import numpy as np
 import random
-import time
 import concurrent.futures
-import matplotlib.pyplot as plt
+from typing import Dict, Any, List
 
-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
 
+
 ########################################
 # 1. Domain Assumption Matrix
 ########################################
 
 class DomainAssumptionMatrix:
     """
-    Stores domain assumptions (e.g., PDE dimension=2D/3D),
-    checks for conflicts across domains if needed.
+    Manages domain-specific assumptions and checks for conflicts.
     """
+
     def __init__(self):
         self.matrix: Dict[str, Dict[str, Any]] = {}
 
     def add_domain(self, domain_name: str, assumptions: Dict[str, Any]) -> str:
         """
-        Add or update domain_name with given assumptions.
-        Example: domain='NavierStokes', assumptions={'dimension': '3D', 'time_dependent': True}
+        Add or update assumptions for a given domain.
         """
         if domain_name not in self.matrix:
             self.matrix[domain_name] = {}
         self.matrix[domain_name].update(assumptions)
-        return f"Domain '{domain_name}' updated with {assumptions}"
+        return f"Domain '{domain_name}' updated with {assumptions}."
 
     def check_conflict(self, domain1: str, domain2: str) -> bool:
         """
-        Return True if domain1 & domain2 have conflicting assumption keys.
-        E.g. domain1['dimension']='2D' vs domain2['dimension']='3D'
+        Check if two domains have conflicting assumptions.
         """
         d1 = self.matrix.get(domain1, {})
         d2 = self.matrix.get(domain2, {})
-        for k, v in d1.items():
-            if k in d2 and d2[k] != v:
+        for key, value in d1.items():
+            if key in d2 and d2[key] != value:
                 return True
         return False
 
     def list_domains(self) -> Dict[str, Dict[str, Any]]:
+        """
+        List all domains with their assumptions.
+        """
         return self.matrix
 
+
 ########################################
 # 2. Confidence Index
 ########################################
 
 class ConfidenceIndex:
     """
-    Track 'conjectures' with a confidence score (0-5).
+    Tracks conjectures with confidence scores.
     """
+
     def __init__(self):
         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.
+        Add or update a conjecture with a confidence score.
         """
         score_clamped = max(0, min(score, 5))
         self.index[conj_id] = {"score": score_clamped}
 
     def update_score(self, conj_id: str, delta: int):
         """
-        Increase or decrease confidence by delta. Clamped to [0, 5].
+        Modify the confidence score of a conjecture.
         """
         if conj_id in self.index:
             old = self.index[conj_id]["score"]
@@ -80,98 +81,74 @@ class ConfidenceIndex:
             self.index[conj_id]["score"] = new_score
 
     def get_score(self, conj_id: str) -> int:
-        if conj_id in self.index:
-            return self.index[conj_id]["score"]
-        return 0
+        """
+        Retrieve the confidence score of a conjecture.
+        """
+        return self.index.get(conj_id, {}).get("score", 0)
 
     def list_all(self) -> Dict[str, Dict[str, Any]]:
+        """
+        List all conjectures with their scores.
+        """
         return self.index
 
+
 ########################################
-# 3. HPC PDE concurrency (FEniCSx)
+# 3. HPC PDE Solver
 ########################################
 
 class HPCSolver:
     """
-    Solves PDEs using FEniCSx and generates visualizations.
+    Simulates HPC PDE solves using CPU-intensive operations.
     """
-    def solve_pde(self, problem_type: str, mesh_size: int) -> str:
+
+    def solve_pde(self, problem_type: str, size: int) -> str:
         """
-        Solve a PDE using FEniCSx and save a plot.
-        Supported problem_type: 'Poisson'
+        Perform a simulated PDE solve and return a result summary.
         """
-        if problem_type == "Poisson":
-            try:
-                # Create mesh
-                domain = mesh.create_unit_square(MPI.COMM_WORLD, mesh_size, mesh_size)
-                
-                # Define function space
-                V = fem.FunctionSpace(domain, ("Lagrange", 1))
-                
-                # Define boundary condition
-                u_D = fem.Function(V)
-                with u_D.vector.localForm() as loc:
-                    loc.set(0.0)
-                
-                def boundary(x):
-                    return np.full(x.shape[1], True)
-                
-                bc = fem.dirichletbc(u_D, fem.locate_dofs_geometrical(V, boundary))
-                
-                # Define variational problem
-                u = fem.TrialFunction(V)
-                v = fem.TestFunction(V)
-                f = fem.Constant(domain, -6.0)
-                a = fem.form(fem.dot(fem.grad(u), fem.grad(v)) * fem.dx)
-                L = fem.form(f * v * fem.dx)
-                
-                # Compute solution
-                u_sol = fem.Function(V)
-                fem.petsc.solve(a == L, u_sol, bc)
-                
-                # Plot solution
-                with dolfinx.io.XDMFFile(domain.comm, "poisson_solution.xdmf", "w") as xdmf:
-                    xdmf.write_mesh(domain)
-                    xdmf.write_function(u_sol)
-                
-                return "Poisson PDE solved. Visualization saved as 'poisson_solution.xdmf'."
-            except Exception as e:
-                return f"Error solving Poisson PDE: {e}"
-        else:
-            return "Unsupported PDE type."
+        try:
+            array = np.random.rand(size, size)
+            s = array.sum()
+            s2 = (array @ array.T).sum()
+            final_val = s2 + s
+            return f"[{problem_type} PDE] size={size}, result={final_val:.4f}"
+        except Exception as e:
+            return f"Error during PDE solve: {e}"
 
     def solve_concurrent(self, tasks: List[str], sizes: List[int]) -> List[str]:
         """
-        Run multiple PDE solves in parallel.
+        Execute multiple PDE solves concurrently.
         """
         results = []
-        def worker(t, sz):
-            return self.solve_pde(t, sz)
 
-        with concurrent.futures.ThreadPoolExecutor() as executor:
-            futmap = {executor.submit(worker, t, s): (t, s) for t, s in zip(tasks, sizes)}
-            for fut in concurrent.futures.as_completed(futmap):
-                results.append(fut.result())
+        def worker(task, size):
+            return self.solve_pde(task, size)
+
+        with concurrent.futures.ProcessPoolExecutor() as executor:
+            futures = [executor.submit(worker, t, s) for t, s in zip(tasks, sizes)]
+            for future in concurrent.futures.as_completed(futures):
+                results.append(future.result())
         return results
 
+
 ########################################
-# 4. Theorem Prover Integration
+# 4. Theorem Prover
 ########################################
 
 class TheoremProver:
     """
-    Integrates with a theorem prover to check proofs.
-    Here, we simulate proof checking with probabilistic success.
+    Simple theorem prover that randomly validates conjectures.
     """
+
     def check_proof(self, statement: str) -> bool:
         """
-        Simulate a theorem proof check.
-        Returns True if proof is successful, False otherwise.
+        Randomly determine if a proof passes based on statement length.
         """
-        # 70% chance to pass if statement length > 10
-        if len(statement) > 10:
-            return random.random() < 0.7
-        return False
+        if len(statement) < 10:
+            return False
+        success_chance = 0.7
+        return random.random() < success_chance
+
 
 ########################################
 # 5. Symbolic Solver
@@ -179,11 +156,12 @@ class TheoremProver:
 
 def symbolic_solve_equation(equation: str, vars_str: str) -> str:
     """
-    Parse equation and variables, perform symbolic solve with SymPy.
+    Solve a symbolic equation for specified variables.
     """
     varlist = [v.strip() for v in vars_str.split(",") if v.strip()]
     if not varlist:
         return "No variables provided."
+
     try:
         syms = symbols(varlist)
         expr = parse_expr(equation)
@@ -193,49 +171,44 @@ def symbolic_solve_equation(equation: str, vars_str: str) -> str:
     except Exception as e:
         return f"Error solving symbolically: {e}"
 
+
 ########################################
-# 6. Machine Learning Enhancements
+# 6. CSV-based ML Model
 ########################################
 
 class MLModel:
     """
-    Handles training and prediction for text classification.
+    Handles training and inference for a text classification model.
     """
+
     def __init__(self):
-        self.vectorizer = None
-        self.classifier = None
-        self.trained = False
+        self.vectorizer: CountVectorizer = CountVectorizer()
+        self.classifier: RandomForestClassifier = RandomForestClassifier()
+        self.trained: bool = False
 
-    def train_from_csv(self, file_obj) -> str:
+    def train_from_csv(self, file_path: str) -> str:
         """
-        Train a RandomForestClassifier from a CSV with 'text' and 'label' columns.
+        Train the model using a CSV file with 'text' and 'label' columns.
         """
         try:
-            # Read CSV
-            df = pd.read_csv(file_obj.name)
+            df = pd.read_csv(file_path)
             if "text" not in df.columns or "label" not in df.columns:
                 return "CSV must contain 'text' and 'label' columns."
 
             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.classifier.fit(X, labels)
             self.trained = True
-
-            return f"Model trained on {len(texts)} samples. Labels: {set(labels)}."
+            distinct_labels = len(set(labels))
+            return f"Model trained on {len(texts)} samples with {distinct_labels} distinct labels."
         except Exception as e:
-            return f"Error during training: {e}"
+            return f"Error training model: {e}"
 
     def chat_response(self, user_input: str) -> str:
         """
-        Generate a response based on the trained model's prediction.
+        Predict the label for a given user input.
         """
         if not self.trained:
             return "Model not trained. Please upload a CSV and train the model first."
@@ -247,228 +220,219 @@ class MLModel:
         except Exception as e:
             return f"Error during prediction: {e}"
 
+
 ########################################
-# 7. Unified Pipeline
+# 7. Combined Pipeline
 ########################################
 
 class HybridAIPipeline:
     """
-    Combines all functionalities into a unified pipeline.
+    Integrates all components of the Hybrid AI system.
     """
+
     def __init__(self):
         self.domains = DomainAssumptionMatrix()
         self.confidence = ConfidenceIndex()
         self.hpcsolver = HPCSolver()
         self.theorem = TheoremProver()
         self.ml_model = MLModel()
-        # Store conjecture text for theorem checks
         self.conjecture_texts: Dict[str, str] = {}
 
     # Domain Management
-    def add_domain(self, domain_name: str, key: str, val: str) -> str:
-        return self.domains.add_domain(domain_name, {key: val})
+    def add_domain(self, domain_name: str, key: str, value: str) -> str:
+        assumptions = {key: value}
+        return self.domains.add_domain(domain_name, assumptions)
 
     def list_domains(self) -> str:
-        domains = self.domains.list_domains()
-        return "\n".join([f"{k}: {v}" for k, v in domains.items()])
+        return pd.DataFrame(self.domains.list_domains()).to_string()
 
     # 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 with initial score {score}."
+        return f"Conjecture '{conj_id}' added with score {score}."
 
     def list_conjectures(self) -> str:
-        conjectures = self.confidence.list_all()
-        return "\n".join([f"{k}: Score={v['score']}" for k, v in conjectures.items()])
+        return pd.DataFrame(self.confidence.list_all()).to_string()
 
     # HPC PDE Solving
     def run_pde_solve(self, problem_type: str, size: int) -> str:
         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: Number of tasks and sizes must match."
         results = self.hpcsolver.solve_concurrent(tasks, sizes)
         return "\n".join(results)
 
-    # Theorem Prover
+    # Theorem Checking
     def check_theorem(self, conj_id: str) -> str:
-        """
-        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 text found for conjecture '{conj_id}'."
+            return f"No statement 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 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 decreased to {self.confidence.get_score(conj_id)}."
-
-    # Symbolic Solver
+        delta = 1 if success else -1
+        self.confidence.update_score(conj_id, delta)
+        status = "PASSED" if success else "FAILED"
+        return f"Theorem check {status} for '{conj_id}'. Confidence {'+1' if success else '-1'}."
+
+    # Symbolic Solving
     def symbolic_solve(self, equation: str, variables: str) -> str:
         return symbolic_solve_equation(equation, variables)
 
-    # ML Training and Chat
-    def train_csv(self, file_obj) -> str:
-        return self.ml_model.train_from_csv(file_obj)
+    # ML Model Training and Chat
+    def train_csv(self, file_path: str) -> str:
+        return self.ml_model.train_from_csv(file_path)
+
+    def chat(self, message: str) -> str:
+        return self.ml_model.chat_response(message)
 
-    def chat(self, user_message: str) -> str:
-        return self.ml_model.chat_response(user_message)
 
 ########################################
 # 8. Gradio Interface
 ########################################
 
-# Initialize the pipeline
 pipeline = HybridAIPipeline()
 
-# 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 list_domains_func():
-    return pipeline.list_domains()
-
-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 train_csv_func(file):
-    if file is None:
-        return "Please upload a CSV file."
-    return pipeline.train_csv(file)
-
-def chat_func(message):
-    if not message.strip():
-        return "Please enter a message."
-    return pipeline.chat(message.strip())
-
-def pde_solve_func(problem, size):
-    return pipeline.run_pde_solve(problem, size)
-
-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)
-
-def theorem_check_func(conj_id):
-    if not conj_id.strip():
-        return "Conjecture ID is required."
-    return pipeline.check_theorem(conj_id.strip())
-
-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())
-
-# Build Gradio Interface
-def build_interface():
+def build_app():
     with gr.Blocks() as demo:
-        gr.Markdown("# Enterprise-Grade Hybrid AI App")
+        gr.Markdown("# Enterprise-Grade Hybrid AI App - Fully Functional")
 
-        with gr.Tab("Domain Assumptions"):
-            gr.Markdown("**Add and manage domain-specific assumptions.**")
+        with gr.Tab("1. Domain Assumptions"):
+            gr.Markdown("**Manage domain 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])
+                domain_name = gr.Textbox(label="Domain Name", placeholder="e.g., NavierStokes")
+                domain_key = gr.Textbox(label="Key", placeholder="e.g., dimension")
+                domain_value = gr.Textbox(label="Value", placeholder="e.g., 3D")
+            add_domain_btn = gr.Button("Add/Update Domain")
+            add_domain_output = gr.Textbox(label="Output")
+
+            add_domain_btn.click(
+                pipeline.add_domain,
+                inputs=[domain_name, domain_key, domain_value],
+                outputs=add_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])
+            list_domains_output = gr.Textbox(label="Domains Data", lines=10)
+
+            list_domains_btn.click(
+                pipeline.list_domains,
+                inputs=None,
+                outputs=list_domains_output
+            )
 
-        with gr.Tab("Conjectures"):
-            gr.Markdown("**Track conjectures with confidence scores and optional text for theorem checks.**")
+        with gr.Tab("2. Conjectures"):
+            gr.Markdown("**Track conjectures with confidence scores.**")
             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)
+                conj_id = gr.Textbox(label="Conjecture ID", placeholder="e.g., C1")
+                conj_score = gr.Slider(label="Confidence Score", minimum=0, maximum=5, step=1, value=3)
+            conj_text = gr.Textbox(label="Conjecture Text", placeholder="Optional: Description of conjecture.")
             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])
+            add_conj_output = gr.Textbox(label="Result")
+
+            add_conj_btn.click(
+                pipeline.add_conjecture,
+                inputs=[conj_id, conj_score, conj_text],
+                outputs=add_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])
+            list_conj_output = gr.Textbox(label="Conjectures Data", lines=10)
 
-        with gr.Tab("Train & Chat"):
-            gr.Markdown("**Train a text classification model from a CSV file and interact via a chatbot.**")
+            list_conj_btn.click(
+                pipeline.list_conjectures,
+                inputs=None,
+                outputs=list_conj_output
+            )
+
+        with gr.Tab("3. Train & Chat"):
+            gr.Markdown("**Train a text classifier from CSV and interact with it.**")
             with gr.Row():
-                file_input = gr.File(label="Upload CSV (columns: text, label)")
+                train_file = 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])
+            train_btn.click(
+                pipeline.train_csv,
+                inputs=train_file,
+                outputs=train_output
+            )
+
+            chat_input = gr.Textbox(label="Your Message", placeholder="Enter text to classify.")
+            chat_btn = gr.Button("Chat")
+            chat_output = gr.Textbox(label="Chat Response")
 
-        with gr.Tab("HPC PDE Solvers"):
-            gr.Markdown("**Simulate solving PDEs using FEniCSx with concurrency support.**")
+            chat_btn.click(
+                pipeline.chat,
+                inputs=chat_input,
+                outputs=chat_output
+            )
+
+        with gr.Tab("4. HPC PDE Solver"):
+            gr.Markdown("**Simulate HPC PDE solves with concurrency.**")
             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)
+                prob_type = gr.Dropdown(label="Problem Type", choices=["Poisson", "NavierStokes"], value="Poisson")
+                size_input = gr.Slider(label="Numeric Size", minimum=10, maximum=100, step=5, value=30)
             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])
+            solve_pde_output = gr.Textbox(label="PDE Result", lines=2)
+
+            solve_pde_btn.click(
+                pipeline.run_pde_solve,
+                inputs=[prob_type, size_input],
+                outputs=solve_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.**")
+                tasks_input = gr.Textbox(label="Tasks (comma-separated)", placeholder="e.g., Poisson,NavierStokes")
+                sizes_input = gr.Textbox(label="Sizes (comma-separated)", placeholder="e.g., 30,40")
+            concurrent_solve_btn = gr.Button("Concurrent PDE Solve")
+            concurrent_solve_output = gr.Textbox(label="Concurrent Results", lines=4)
+
+            concurrent_solve_btn.click(
+                lambda tasks, sizes: pipeline.run_concurrent_pde(
+                    [t.strip() for t in tasks.split(",") if t.strip()],
+                    [int(s.strip()) for s in sizes.split(",") if s.strip().isdigit()]
+                ) if tasks and sizes else "Please provide valid tasks and sizes.",
+                inputs=[tasks_input, sizes_input],
+                outputs=concurrent_solve_output
+            )
+
+        with gr.Tab("5. Theorem & Symbolic Solve"):
+            gr.Markdown("**Validate 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])
+                theorem_conj_id = gr.Textbox(label="Conjecture ID", placeholder="e.g., C1")
+                theorem_btn = gr.Button("Check Theorem")
+            theorem_output = gr.Textbox(label="Theorem Output", lines=2)
+
+            theorem_btn.click(
+                pipeline.check_theorem,
+                inputs=theorem_conj_id,
+                outputs=theorem_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])
+                equation_input = gr.Textbox(label="Equation", placeholder="e.g., x**2 - 4")
+                variables_input = gr.Textbox(label="Variables (comma-separated)", placeholder="e.g., x")
+            solve_eq_btn = gr.Button("Symbolic Solve")
+            solve_eq_output = gr.Textbox(label="Solution", lines=2)
 
-        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.")
+            solve_eq_btn.click(
+                pipeline.symbolic_solve,
+                inputs=[equation_input, variables_input],
+                outputs=solve_eq_output
+            )
+
+        gr.Markdown("## 🚀 The Hybrid AI System is Ready!")
 
     return demo
 
-# Launch the Gradio app
-app = build_interface()
-app.launch()
+
+def main():
+    app = build_app()
+    app.launch()
+
+if __name__ == "__main__":
+    main()