Upload 3 files

app.py

@@ -0,0 +1,29 @@
+
+import gradio as gr
+from tmfs_topo import TMFS, CONFIG
+
+def run_sim(n_agents, steps, phase_step):
+    CONFIG["n_agents"] = n_agents
+    CONFIG["steps"] = steps
+    CONFIG["phase_step"] = phase_step
+
+    sim = TMFS()
+    sim.run()
+
+    final_dna = [a.dna for a in sim.agents]
+    return f"Simulation complete. Final symbolic DNA: {final_dna}"
+
+iface = gr.Interface(
+    fn=run_sim,
+    inputs=[
+        gr.Slider(2, 10, value=5, label="Number of Agents"),
+        gr.Slider(10, 100, value=50, step=10, label="Simulation Steps"),
+        gr.Slider(0.01, 0.5, value=0.15, label="Toroidal Phase Step")
+    ],
+    outputs="text",
+    title="Toroidal Morphic Field Simulator (TMFS)",
+    description="Live demo of symbolic agents evolving with morphic memory, DNA mutation, and topological phase logic."
+)
+
+if __name__ == "__main__":
+    iface.launch()

requirements (1).txt

@@ -0,0 +1,4 @@
+torch
+numpy
+matplotlib
+gradio

tmfs_topo.py

@@ -0,0 +1,136 @@
+
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Config
+CONFIG = {
+    "n_agents": 5,
+    "steps": 50,
+    "memory_capacity": 10,
+    "field_decay": 0.1,
+    "move_weight": 0.3,
+    "grid_size": 10.0,
+    "phase_step": 0.15,
+}
+
+SYMBOL_VECTORS = {
+    "∑": torch.tensor([1.0, 0.0]),
+    "Ω": torch.tensor([0.0, 1.0]),
+    "ε₀": torch.tensor([-1.0, -1.0]),
+    "∇": torch.tensor([1.0, 1.0]),
+    "Φ": torch.tensor([0.0, -1.0]),
+    "λ": torch.tensor([-1.0, 0.0]),
+}
+
+class SymbolicMemory:
+    def __init__(self, capacity=CONFIG["memory_capacity"]):
+        self.memory = []
+        self.capacity = capacity
+
+    def store(self, symbol):
+        if len(self.memory) >= self.capacity:
+            self.memory.pop(0)
+        self.memory.append(symbol)
+
+    def get_sequence(self):
+        return self.memory.copy() if self.memory else []
+
+class Agent:
+    def __init__(self, position):
+        self.position = torch.tensor(position, dtype=torch.float32)
+        self.dna = ["∑", "Ω", "ε₀"]
+        self.memory = SymbolicMemory()
+        self.theta = 0.0
+
+    def update_phase(self, delta=CONFIG["phase_step"]):
+        self.theta = (self.theta + delta) % (2 * np.pi)
+
+    def emit_symbol(self, target):
+        distance = torch.norm(self.position - target).item()
+        idx = min(int(distance / 2), len(self.dna) - 1)
+        symbol = self.dna[idx]
+        self.memory.store(symbol)
+        return symbol
+
+    def evolve_dna(self, entropy):
+        if not self.memory.get_sequence():
+            return self.dna[0]
+        current = self.dna[0]
+        if entropy < 0.9 and current == "∑":
+            self.dna[0] = "Ω"
+        elif abs(self.theta - 2 * np.pi) < 0.1 and current == "Ω":
+            self.dna[0] = "ε₀"
+        return self.dna[0]
+
+    def move(self, field_vector, target):
+        field_pull = field_vector - self.position
+        target_pull = target - self.position
+        self.position += CONFIG["move_weight"] * (field_pull + target_pull)
+
+class MorphicField:
+    def __init__(self):
+        self.position_memory = []
+        self.symbol_counts = {}
+
+    def update(self, positions, symbols):
+        self.position_memory.append(positions.clone())
+        if len(self.position_memory) > 50:
+            self.position_memory.pop(0)
+        for symbol in symbols:
+            self.symbol_counts[symbol] = self.symbol_counts.get(symbol, 0) + 1
+
+    def get_field(self, symbols):
+        pos_field = torch.zeros(2)
+        if self.position_memory:
+            weights = torch.exp(-CONFIG["field_decay"] * torch.arange(len(self.position_memory), 0, -1))
+            weights /= weights.sum()
+            pos_field = sum(w * p.mean(dim=0) for w, p in zip(weights, self.position_memory))
+        sym_field = torch.zeros(2)
+        for sym in symbols:
+            sym_field += SYMBOL_VECTORS.get(sym, torch.zeros(2))
+        return pos_field + (sym_field / len(symbols) if symbols else torch.zeros(2))
+
+    def dominant_symbol(self):
+        return max(self.symbol_counts, key=self.symbol_counts.get) if self.symbol_counts else "Ω"
+
+class Tracker:
+    def __init__(self):
+        self.entropy = []
+        self.convergence = []
+        self.symbol_log = []
+
+    def update(self, positions, target, step, agents):
+        center = positions.mean(dim=0)
+        entropy = torch.norm(positions - center, dim=1).std().item() if len(positions) > 1 else 0
+        convergence = torch.norm(positions - target, dim=1).mean().item()
+        self.entropy.append(entropy)
+        self.convergence.append(convergence)
+        for i, agent in enumerate(agents):
+            self.symbol_log.append((step, agent.position.tolist(), agent.dna[0], agent.theta))
+
+class TMFS:
+    def __init__(self):
+        self.agents = [Agent([np.random.rand()*CONFIG["grid_size"],
+                              np.random.rand()*CONFIG["grid_size"]])
+                       for _ in range(CONFIG["n_agents"])]
+        self.field = MorphicField()
+        self.target = torch.tensor([CONFIG["grid_size"]/2, CONFIG["grid_size"]/2])
+        self.tracker = Tracker()
+
+    def step(self, t):
+        positions = torch.stack([a.position for a in self.agents])
+        symbols = [a.emit_symbol(self.target) for a in self.agents]
+        field_vector = self.field.get_field(symbols)
+
+        for agent in self.agents:
+            agent.update_phase()
+            agent.evolve_dna(self.tracker.entropy[-1] if self.tracker.entropy else 2.0)
+            agent.move(field_vector, self.target)
+
+        self.field.update(positions, symbols)
+        self.tracker.update(positions, self.target, t, self.agents)
+
+    def run(self):
+        for t in range(CONFIG["steps"]):
+            self.step(t)