Update app.py

app.py

@@ -181,21 +181,6 @@ class NebulaEmergent:
         positions = np.array([n.position for n in self.neurons])
         self.kdtree = KDTree(positions)
         
-    @jit(nopython=True)
-    def compute_gravitational_forces_fast(positions, masses, forces):
-        """Fast gravitational force computation using Numba"""
-        n = len(positions)
-        for i in prange(n):
-            for j in range(i + 1, n):
-                r = positions[j] - positions[i]
-                r_mag = np.sqrt(np.sum(r * r))
-                if r_mag > 1e-10:
-                    f_mag = G * masses[i] * masses[j] / (r_mag ** 2 + 1e-10)
-                    f = f_mag * r / r_mag
-                    forces[i] += f
-                    forces[j] -= f
-        return forces
-        
     def compute_gravitational_forces(self):
         """Compute gravitational forces using Barnes-Hut algorithm approximation"""
         if not self.gravity_enabled:
@@ -205,9 +190,17 @@ class NebulaEmergent:
         masses = np.array([n.mass for n in self.neurons])
         forces = np.zeros((self.n_neurons, 3))
         
-        # Use fast computation for smaller systems
+        # Direct computation for smaller systems
         if self.n_neurons < 5000:
-            forces = self.compute_gravitational_forces_fast(positions, masses, forces)
+            for i in range(self.n_neurons):
+                for j in range(i + 1, self.n_neurons):
+                    r = positions[j] - positions[i]
+                    r_mag = np.linalg.norm(r)
+                    if r_mag > 1e-10:
+                        f_mag = G * masses[i] * masses[j] / (r_mag ** 2 + 1e-10)
+                        f = f_mag * r / r_mag
+                        forces[i] += f
+                        forces[j] -= f
         else:
             # Barnes-Hut approximation for larger systems
             # Group nearby neurons and treat as single mass
@@ -599,7 +592,9 @@ class NebulaInterface:
     def evolve_step(self):
         """Evolve system by one step"""
         if self.nebula is None:
-            return "⚠️ Please create a system first", go.Figure(), go.Figure()
+            # Auto-create system with default settings
+            self.nebula = NebulaEmergent(1000)
+            return "⚠️ System auto-created with 1000 neurons. Click again to evolve.", self.visualize_3d(), self.create_metrics_plot()
             
         self.nebula.evolve()
         
@@ -616,10 +611,11 @@ class NebulaInterface:
     def evolve_continuous(self, steps: int):
         """Evolve system continuously for multiple steps"""
         if self.nebula is None:
-            return "⚠️ Please create a system first", go.Figure(), go.Figure()
+            # Auto-create system with default settings
+            self.nebula = NebulaEmergent(1000)
             
         status_messages = []
-        for i in range(steps):
+        for i in range(int(steps)):  # Ensure steps is integer
             self.nebula.evolve()
             
             # Store metrics
@@ -633,17 +629,17 @@ class NebulaInterface:
                                       f"Clusters={self.nebula.metrics['clusters']}, "
                                       f"Emergence={self.nebula.metrics['emergence_score']:.3f}")
                 
-        return ("\\n".join(status_messages[-5:]), 
+        return ("\n".join(status_messages[-5:]), 
                 self.visualize_3d(), 
                 self.create_metrics_plot())
                 
     def encode_image_problem(self, image):
         """Encode an image as a problem"""
         if self.nebula is None:
-            return "⚠️ Please create a system first"
+            self.nebula = NebulaEmergent(5000)
             
         if image is None:
-            return "⚠️ Please upload an image"
+            return "⚠️ Please upload an image", self.visualize_3d()
             
         # Convert image to grayscale and resize
         from PIL import Image
@@ -656,13 +652,15 @@ class NebulaInterface:
         # Encode in system
         self.nebula.encode_problem(img_array)
         
-        return f"✅ Image encoded into system"
+        return f"✅ Image encoded into system", self.visualize_3d()
         
     def solve_tsp(self, n_cities: int):
         """Solve Traveling Salesman Problem"""
         if self.nebula is None:
-            return "⚠️ Please create a system first", go.Figure()
+            self.nebula = NebulaEmergent(3000)
             
+        n_cities = int(n_cities)  # Ensure integer
+        
         # Generate random cities
         cities = np.random.random((n_cities, 2))
         
@@ -750,6 +748,9 @@ class NebulaInterface:
 def create_gradio_app():
     interface = NebulaInterface()
     
+    # Auto-initialize with default system
+    interface.nebula = NebulaEmergent(1000)
+    
     with gr.Blocks(title="NEBULA EMERGENT - Physical Neural Computing") as app:
         gr.Markdown("""
         # 🌌 NEBULA EMERGENT - Physical Neural Computing System
@@ -779,17 +780,18 @@ def create_gradio_app():
                     create_btn = gr.Button("🔨 Create System", variant="primary")
                     
                     gr.Markdown("### Evolution Control")
+                    gr.Markdown("*System auto-creates if not initialized*")
                     step_btn = gr.Button("▶️ Single Step")
                     
                     with gr.Row():
-                        steps_input = gr.Number(value=100, label="Steps")
+                        steps_input = gr.Number(value=100, label="Steps", precision=0)
                         run_btn = gr.Button("🏃 Run Multiple Steps", variant="primary")
                         
                     status_text = gr.Textbox(label="Status", lines=5)
                     
                 with gr.Column(scale=2):
-                    plot_3d = gr.Plot(label="3D Neuron Visualization")
-                    metrics_plot = gr.Plot(label="System Metrics")
+                    plot_3d = gr.Plot(label="3D Neuron Visualization", value=interface.visualize_3d())
+                    metrics_plot = gr.Plot(label="System Metrics", value=interface.create_metrics_plot())
                     
         with gr.Tab("🧩 Problem Solving"):
             with gr.Row():
@@ -888,7 +890,7 @@ def create_gradio_app():
         encode_img_btn.click(
             interface.encode_image_problem,
             inputs=[image_input],
-            outputs=[problem_status]
+            outputs=[problem_status, solution_plot]
         )
         
         solve_tsp_btn.click(