Update app.py

app.py

@@ -3,7 +3,7 @@ import time
 import collections
 import threading
 import random
-from fastapi import FastAPI, Request
+from fastapi import FastAPI
 from fastapi.responses import HTMLResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
@@ -16,7 +16,8 @@ class SimEngine:
         self.nodes = {}       
         self.running = False
         self.mode = 'inference'       
-        self.problem_type = 'add' # Restored: 'add' or 'mult'
+        self.problem_type = 'housing' # add, mult, housing, sub, div
+        self.mesh_depth = 2
         self.batch_queue = collections.deque()
         self.logs = []
         self.iteration = 0
@@ -24,72 +25,70 @@ class SimEngine:
         self.reset()
 
     def reset(self):
-        # A & B are Inputs, C is Output
-        self.nodes = {
-            'A': {'x': 2.0, 'anchored': True, 'k': 1.0, 'f': 0.0},
-            'B': {'x': 3.0, 'anchored': True, 'k': 1.0, 'f': 0.0}, 
-            'C': {'x': 5.0, 'anchored': False, 'k': 1.0, 'f': 0.0}  
-        }
+        self.nodes = {}
+        # Fixed Anchors
+        self.nodes['A'] = {'x': 1.0, 'y': 2.0, 'anchored': True, 'k': 1.0}
+        self.nodes['B'] = {'x': 1.0, 'y': -2.0, 'anchored': True, 'k': 1.0}
+        self.nodes['C'] = {'x': 1.0, 'y': 0.0, 'anchored': False, 'k': 1.0}
+
+        # Generate Multicellular Mesh between A->C and B->C
+        for i in range(self.mesh_depth):
+            self.nodes[f'H_AC_{i}'] = {'x': random.uniform(0, 1), 'y': 1.0, 'anchored': False, 'k': random.uniform(0.1, 1.0)}
+            self.nodes[f'H_BC_{i}'] = {'x': random.uniform(0, 1), 'y': -1.0, 'anchored': False, 'k': random.uniform(0.1, 1.0)}
+
         self.batch_queue.clear()
         self.logs = []
         self.iteration = 0
-        self.current_error = 0.0
+        self.add_log(f"Mesh Reset: Depth {self.mesh_depth}")
 
     def add_log(self, msg):
         self.logs.insert(0, f"[{self.iteration}]: {msg}")
-        if len(self.logs) > 20: self.logs.pop()
+        if len(self.logs) > 15: self.logs.pop()
 
     def set_problem(self, a, b, c_target=None):
         self.nodes['A']['x'] = float(a)
         self.nodes['B']['x'] = float(b)
-        
         if self.mode == 'training':
             self.nodes['C']['x'] = float(c_target)
             self.nodes['C']['anchored'] = True
-            symbol = "+" if self.problem_type == 'add' else "*"
-            self.add_log(f"TRAIN: {a} {symbol} {b} = {c_target}")
         else:
             self.nodes['C']['anchored'] = False
-            self.nodes['C']['x'] = random.uniform(-5, 5) # Random start for C
-            self.add_log(f"INFER: {a} {self.problem_type} {b} = ?")
+            self.nodes['C']['x'] = random.uniform(0, 10)
 
     def physics_step(self):
-        na, nb, nc = self.nodes['A'], self.nodes['B'], self.nodes['C']
+        # 1. Forward Pass: Summing the chains
+        # We simulate the "Law" as a chain of K-stiffness through the hidden cells
+        val_ac = self.nodes['A']['x']
+        for i in range(self.mesh_depth):
+            val_ac *= self.nodes[f'H_AC_{i}']['k']
         
-        # 1. Calculate Base Logic Value
-        if self.problem_type == 'add':
-            base_val = na['x'] + nb['x']
-        else:
-            base_val = na['x'] * nb['x']
+        val_bc = self.nodes['B']['x']
+        for i in range(self.mesh_depth):
+            val_bc *= self.nodes[f'H_BC_{i}']['k']
 
-        # 2. Apply Learned Stiffness (K) to get Prediction
-        prediction = base_val * nc['k']
-        self.current_error = prediction - nc['x']
-        
-        # Convergence Check
-        if abs(self.current_error) < 0.01:
+        # The relationship is the sum of the two mesh flows
+        prediction = val_ac + val_bc
+        self.current_error = prediction - self.nodes['C']['x']
+
+        if abs(self.current_error) < 0.05:
             if self.batch_queue:
                 p = self.batch_queue.popleft()
                 self.set_problem(p['a'], p['b'], p['c'])
                 return True
             else:
                 self.running = False
-                self.add_log("Task Complete.")
                 return False
 
+        # 2. Back-Propagating Tension
         if self.mode == 'inference':
-            # Solve for C: Drift C to meet the prediction
-            move = self.current_error * 0.1
-            nc['x'] += move
-            nc['f'] = move
-            
+            # Drift C to meet the mesh output
+            self.nodes['C']['x'] += self.current_error * 0.1
         elif self.mode == 'training':
-            # Solve for K: Adapt internal stiffness to match clamped C
-            # Target K is the ratio needed to make base_val * K = nc['x']
-            target_k = nc['x'] / (base_val + 1e-9)
-            k_error = target_k - nc['k']
-            nc['k'] += k_error * 0.05 # Learning rate
-            nc['f'] = k_error
+            # Update K factors in the mesh to minimize error
+            adjustment = self.current_error * 0.01
+            for i in range(self.mesh_depth):
+                self.nodes[f'H_AC_{i}']['k'] -= adjustment
+                self.nodes[f'H_BC_{i}']['k'] -= adjustment
 
         self.iteration += 1
         return True
@@ -108,41 +107,37 @@ async def get_ui(): return FileResponse("index.html")
 
 @app.get("/state")
 async def get_state():
-    return {'nodes': engine.nodes, 'error': engine.current_error, 'iter': engine.iteration, 'logs': engine.logs, 'type': engine.problem_type}
+    return {'nodes': engine.nodes, 'error': engine.current_error, 'iter': engine.iteration, 'logs': engine.logs}
 
 @app.post("/config")
 async def config(data: dict):
     engine.mode = data['mode']
+    engine.mesh_depth = int(data['depth'])
     engine.problem_type = data['type']
     engine.running = False
-    engine.add_log(f"Config: {engine.mode} | Logic: {engine.problem_type}")
+    engine.reset()
     return {"ok": True}
 
-@app.post("/generate_batch")
-async def gen_batch(data: dict):
+@app.post("/generate")
+async def generate(data: dict):
     engine.batch_queue.clear()
-    count = int(data['count'])
-    for _ in range(count):
-        a = random.randint(1, 15)
-        b = random.randint(1, 15)
-        c = (a + b) if engine.problem_type == 'add' else (a * b)
+    for _ in range(20):
+        a = random.uniform(1, 10)
+        b = random.uniform(1, 10)
+        # Housing Rule: Location(a) * 2 + Size(b) * 0.5 = Price(c)
+        if engine.problem_type == 'housing': c = (a * 2.5) + (b * 1.2)
+        elif engine.problem_type == 'sub': c = a - b
+        elif engine.problem_type == 'div': c = a / (b + 0.1)
+        else: c = a + b
         engine.batch_queue.append({'a': a, 'b': b, 'c': c})
     p = engine.batch_queue.popleft()
     engine.set_problem(p['a'], p['b'], p['c'])
     engine.running = True
     return {"ok": True}
 
-@app.post("/test_custom")
-async def test_custom(data: dict):
-    engine.mode = 'inference'
-    engine.set_problem(data['a'], data['b'])
-    engine.running = True
-    return {"ok": True}
-
 @app.post("/halt")
 async def halt():
     engine.running = False
-    engine.reset()
     return {"ok": True}
 
 if __name__ == "__main__":