Delete tmfs_topo.py

tmfs_topo.py

@@ -1,136 +0,0 @@
-
-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)