Update app.py

app.py

@@ -16,7 +16,7 @@ class SimEngine:
         self.nodes = {}       
         self.running = False
         self.mode = 'inference'       
-        self.problem_type = 'mult'     
+        self.problem_type = 'add' # Restored: 'add' or 'mult'
         self.batch_queue = collections.deque()
         self.logs = []
         self.iteration = 0
@@ -24,11 +24,11 @@ class SimEngine:
         self.reset()
 
     def reset(self):
-        # A & B are the "Inputs", C is the "Model Output"
+        # 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': 6.0, 'anchored': False, 'k': 1.0, 'f': 0.0}  
+            'C': {'x': 5.0, 'anchored': False, 'k': 1.0, 'f': 0.0}  
         }
         self.batch_queue.clear()
         self.logs = []
@@ -44,26 +44,29 @@ class SimEngine:
         self.nodes['B']['x'] = float(b)
         
         if self.mode == 'training':
-            # In Training, everything is locked to learn the K-factor
             self.nodes['C']['x'] = float(c_target)
             self.nodes['C']['anchored'] = True
-            self.add_log(f"TRAIN: {a} * {b} = {c_target}")
+            symbol = "+" if self.problem_type == 'add' else "*"
+            self.add_log(f"TRAIN: {a} {symbol} {b} = {c_target}")
         else:
-            # In Inference, C is free to drift to the predicted answer
             self.nodes['C']['anchored'] = False
-            # Start C at a random point to see it "find" the answer
-            self.nodes['C']['x'] = random.uniform(-10, 10)
-            self.add_log(f"INFER: {a} * {b} = ?")
+            self.nodes['C']['x'] = random.uniform(-5, 5) # Random start for C
+            self.add_log(f"INFER: {a} {self.problem_type} {b} = ?")
 
     def physics_step(self):
         na, nb, nc = self.nodes['A'], self.nodes['B'], self.nodes['C']
         
-        # Calculate the "Stress" of the current logic
-        # Pred = (A * B) * (The learned stiffness of the connection)
-        learned_k = nc['k']
-        prediction = (na['x'] * nb['x']) * learned_k
+        # 1. Calculate Base Logic Value
+        if self.problem_type == 'add':
+            base_val = na['x'] + nb['x']
+        else:
+            base_val = na['x'] * nb['x']
+
+        # 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:
             if self.batch_queue:
                 p = self.batch_queue.popleft()
@@ -75,18 +78,17 @@ class SimEngine:
                 return False
 
         if self.mode == 'inference':
-            # Move C (The Output) to satisfy the learned K
-            # If error is positive (pred > C), we must increase C
+            # Solve for C: Drift C to meet the prediction
             move = self.current_error * 0.1
             nc['x'] += move
             nc['f'] = move
             
         elif self.mode == 'training':
-            # C is locked. We must adjust K to make (A*B)*K = C
-            # Gradient Descent on the Stiffness
-            target_k = nc['x'] / (na['x'] * nb['x'] + 1e-9)
+            # 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['k'] += k_error * 0.05 # Learning rate
             nc['f'] = k_error
 
         self.iteration += 1
@@ -97,7 +99,7 @@ engine = SimEngine()
 def run_loop():
     while True:
         if engine.running: engine.physics_step()
-        time.sleep(0.05)
+        time.sleep(0.04)
 
 threading.Thread(target=run_loop, daemon=True).start()
 
@@ -106,21 +108,25 @@ 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}
+    return {'nodes': engine.nodes, 'error': engine.current_error, 'iter': engine.iteration, 'logs': engine.logs, 'type': engine.problem_type}
 
 @app.post("/config")
 async def config(data: dict):
     engine.mode = data['mode']
+    engine.problem_type = data['type']
     engine.running = False
+    engine.add_log(f"Config: {engine.mode} | Logic: {engine.problem_type}")
     return {"ok": True}
 
-@app.post("/generate_factors")
-async def gen_factors(data: dict):
+@app.post("/generate_batch")
+async def gen_batch(data: dict):
     engine.batch_queue.clear()
-    for _ in range(int(data['count'])):
-        a = random.randint(1, 10)
-        b = random.randint(1, 10)
-        engine.batch_queue.append({'a': a, 'b': b, 'c': a * b})
+    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)
+        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