Create app.py

app.py

@@ -0,0 +1,412 @@
+import gradio as gr
+import numpy as np
+import time
+import json
+import hashlib
+from dataclasses import dataclass
+
+# =========================
+# Artifact metadata
+# =========================
+ARTIFACT = "RFT_Conscious_Civilization_Simulator_Teachers_v1"
+AUTHOR = "Liam Grinstead"
+REGISTRY = "Codex_Consciousness + Civilization Ledger"
+
+def sha512_str(s: str) -> str:
+    return hashlib.sha512(s.encode("utf-8")).hexdigest()
+
+# =========================
+# Color palette (RGB)
+# =========================
+COLORS = {
+    "EMPTY": (255, 255, 255),      # white
+    "MALE": (30, 144, 255),        # blue
+    "FEMALE": (255, 105, 180),     # pink
+    "BABY": (255, 235, 59),        # yellow
+    "WORKER": (150, 150, 255),     # light blue
+    "BUILDING": (128, 128, 128),   # gray
+    "SHOP": (255, 165, 0),         # orange
+    "ROAD": (0, 0, 0),             # black
+    "FOREST": (34, 139, 34),       # green
+    "FOOD": (144, 238, 144),       # lime
+    "TEACHER": (128, 0, 128),      # purple
+    "GUILD": (102, 51, 153),       # gray-purple (school)
+}
+
+# =========================
+# Entity codes
+# =========================
+EMPTY, MALE, FEMALE, BABY, WORKER, BUILDING, SHOP, ROAD, FOREST, FOOD, TEACHER, GUILD = range(12)
+
+# =========================
+# Parameters & state
+# =========================
+@dataclass
+class SimParams:
+    width: int = 64
+    height: int = 64
+    male_init: int = 120
+    female_init: int = 120
+    teacher_init: int = 6
+    forest_fraction: float = 0.20
+    food_fraction: float = 0.05
+    shop_ratio: float = 0.06
+    building_seed: int = 6
+    road_bias: float = 0.40
+    baby_age_ticks: int = 8
+    pair_prob_base: float = 0.02
+    worker_productivity: float = 0.25
+    food_need_per_capita: float = 0.005
+    override_sensitivity: float = 0.60
+    teacher_radius: int = 6
+
+class Civilization:
+    def __init__(self, params: SimParams, seed: int = 7):
+        self.params = params
+        self.rng = np.random.default_rng(seed)
+        self.grid = np.full((params.height, params.width), EMPTY, dtype=np.uint8)
+        self.age_grid = np.zeros_like(self.grid, dtype=np.uint16)
+        self.food_stock = np.zeros_like(self.grid, dtype=np.float32)
+        self.tick = 0
+
+        # Seed forests and food
+        forest_mask = self.rng.random(self.grid.shape) < params.forest_fraction
+        self.grid[forest_mask] = FOREST
+        food_mask = (self.rng.random(self.grid.shape) < params.food_fraction) & (self.grid == EMPTY)
+        self.grid[food_mask] = FOOD
+        self.food_stock[food_mask] = 1.0
+
+        # Seed buildings
+        for _ in range(params.building_seed):
+            y = self.rng.integers(0, params.height)
+            x = self.rng.integers(0, params.width)
+            self.grid[y, x] = BUILDING
+
+        # Seed shops near buildings
+        shop_spots = np.argwhere(self.grid == BUILDING)
+        for (y, x) in shop_spots[:max(1, int(len(shop_spots) * params.shop_ratio))]:
+            for ny, nx in self._neighbors8(y, x):
+                if self.grid[ny, nx] == EMPTY and self.rng.random() < 0.5:
+                    self.grid[ny, nx] = SHOP
+
+        # Seed males & females
+        empties = np.argwhere(self.grid == EMPTY)
+        self.rng.shuffle(empties)
+        for (y, x) in empties[:params.male_init]:
+            self.grid[y, x] = MALE
+        for (y, x) in empties[params.male_init:params.male_init + params.female_init]:
+            self.grid[y, x] = FEMALE
+
+        # Seed teacher agents
+        remaining = [tuple(p) for p in empties[params.male_init + params.female_init:]]
+        self.rng.shuffle(remaining)
+        for (y, x) in remaining[:params.teacher_init]:
+            self.grid[y, x] = TEACHER
+
+    def _neighbors8(self, y, x):
+        H, W = self.grid.shape
+        for dy in (-1, 0, 1):
+            for dx in (-1, 0, 1):
+                if dy == 0 and dx == 0:
+                    continue
+                ny, nx = (y + dy) % H, (x + dx) % W
+                yield ny, nx
+
+    def _majority(self, cells):
+        vals, counts = np.unique(cells, return_counts=True)
+        return int(vals[np.argmax(counts)])
+
+    def teacher_influence(self, y, x, radius=None):
+        if radius is None:
+            radius = self.params.teacher_radius
+        H, W = self.grid.shape
+        y0, y1 = max(0, y - radius), min(H, y + radius + 1)
+        x0, x1 = max(0, x - radius), min(W, x + radius + 1)
+        block = self.grid[y0:y1, x0:x1]
+        return int(np.sum((block == TEACHER) | (block == GUILD)))
+
+    def conscious_override(self, local_food, local_density, local_buildings, teacher_influence):
+        # Collapse pressure: low food + high density; teachers reduce pressure by raising override willingness
+        pressure = (1.0 - min(1.0, local_food)) * 0.6 + local_density * 0.4
+        base = pressure > self.params.override_sensitivity or (local_buildings == 0 and local_density > 0.5)
+        if teacher_influence > 0:
+            # 20% chance to choose override even if base threshold not met
+            base = base or (self.rng.random() < 0.2)
+        return base
+
+    def step(self):
+        H, W = self.grid.shape
+        new_grid = self.grid.copy()
+        new_age = self.age_grid.copy()
+        new_food = self.food_stock.copy()
+
+        # regenerate forests slightly
+        forest_regen = (self.grid == FOREST)
+        new_food[forest_regen] += 0.01
+
+        # consume food by population
+        pop_mask = (self.grid == MALE) | (self.grid == FEMALE) | (self.grid == BABY) | (self.grid == WORKER)
+        new_food[pop_mask] -= self.params.food_need_per_capita
+        new_food = np.clip(new_food, 0.0, 5.0)
+
+        for y in range(H):
+            for x in range(W):
+                cell = self.grid[y, x]
+                nb = [(ny, nx) for ny, nx in self._neighbors8(y, x)]
+                nb_cells = np.array([self.grid[ny, nx] for ny, nx in nb], dtype=np.uint8)
+                nb_food = float(np.mean([self.food_stock[ny, nx] for ny, nx in nb]))
+                nb_density = float(np.mean([1.0 if self.grid[ny, nx] in (MALE, FEMALE, BABY, WORKER) else 0.0 for ny, nx in nb]))
+                nb_buildings = int(np.sum(nb_cells == BUILDING))
+                teacher_inf = self.teacher_influence(y, x)
+
+                # Conscious override decision
+                override = self.conscious_override(local_food=nb_food, local_density=nb_density, local_buildings=nb_buildings, teacher_influence=teacher_inf)
+
+                if cell in (MALE, FEMALE):
+                    has_pair = (MALE in nb_cells and FEMALE in nb_cells)
+                    pair_prob = self.params.pair_prob_base * (1.0 + min(1.0, nb_food)) * (1.0 + 0.25 * nb_buildings)
+                    if teacher_inf > 0:
+                        pair_prob *= 1.5  # teachers boost pairing
+                    if has_pair and self.rng.random() < pair_prob:
+                        empties = [(ny, nx) for (ny, nx), c in zip(nb, nb_cells) if c == EMPTY]
+                        if empties:
+                            ty, tx = empties[self.rng.integers(0, len(empties))]
+                            new_grid[ty, tx] = BABY
+                            new_age[ty, tx] = 0
+                    # Optional: teacher-led immediate shelter/food placement under override
+                    if override and self.rng.random() < 0.12:
+                        target_type = FOOD if nb_food < 0.5 else BUILDING
+                        candidates = [(ny, nx) for (ny, nx), c in zip(nb, nb_cells) if c == EMPTY]
+                        if candidates:
+                            ty, tx = candidates[self.rng.integers(0, len(candidates))]
+                            new_grid[ty, tx] = target_type
+                            if target_type == FOOD:
+                                new_food[ty, tx] += 0.4
+
+                elif cell == BABY:
+                    # ageing into worker (babies near teachers age faster)
+                    inc = 1 + (1 if teacher_inf > 0 else 0)
+                    new_age[y, x] = self.age_grid[y, x] + inc
+                    if new_age[y, x] >= self.params.baby_age_ticks:
+                        new_grid[y, x] = WORKER
+
+                elif cell == WORKER:
+                    # workers build roads, buildings, or harvest food
+                    choice = self.rng.random()
+                    if override:
+                        if nb_food < 0.5 and choice < 0.6:
+                            new_grid[y, x] = FOOD
+                            new_food[y, x] += 0.3
+                        elif choice < 0.9:
+                            new_grid[y, x] = ROAD
+                        else:
+                            new_grid[y, x] = BUILDING
+                    else:
+                        if choice < 0.33:
+                            new_grid[y, x] = BUILDING
+                        elif choice < 0.66:
+                            new_grid[y, x] = ROAD
+                        else:
+                            new_grid[y, x] = FOOD
+                            new_food[y, x] += 0.2
+
+                elif cell == BUILDING:
+                    # shops emerge near buildings over time
+                    if self.rng.random() < 0.02:
+                        candidates = [(ny, nx) for (ny, nx), c in zip(nb, nb_cells) if c == EMPTY]
+                        if candidates:
+                            ty, tx = candidates[self.rng.integers(0, len(candidates))]
+                            new_grid[ty, tx] = SHOP
+
+                elif cell == SHOP:
+                    # convert surplus food to prosperity -> attracts agents
+                    if nb_food > 0.8 and self.rng.random() < 0.05:
+                        candidates = [(ny, nx) for (ny, nx), c in zip(nb, nb_cells) if c == EMPTY]
+                        if candidates:
+                            ty, tx = candidates[self.rng.integers(0, len(candidates))]
+                            new_grid[ty, tx] = MALE if self.rng.random() < 0.5 else FEMALE
+
+                elif cell == FOREST:
+                    # harvesting creates food slots; excessive pressure reduces forest
+                    if nb_density > 0.4 and nb_food < 0.5 and self.rng.random() < 0.06:
+                        new_grid[y, x] = FOOD
+                        new_food[y, x] += 0.4
+
+                elif cell == ROAD:
+                    # roads extend toward population centers
+                    if self.rng.random() < self.params.road_bias:
+                        tgt = self._majority(nb_cells)
+                        if tgt in (BUILDING, SHOP, MALE, FEMALE, WORKER, BABY) and self.rng.random() < 0.4:
+                            candidates = [(ny, nx) for (ny, nx), c in zip(nb, nb_cells) if c == EMPTY]
+                            if candidates:
+                                ty, tx = candidates[self.rng.integers(0, len(candidates))]
+                                new_grid[ty, tx] = ROAD
+
+                elif cell == TEACHER:
+                    # Teachers can spawn guild buildings
+                    if self.rng.random() < 0.01:
+                        candidates = [(ny, nx) for (ny, nx), c in zip(nb, nb_cells) if c == EMPTY]
+                        if candidates:
+                            ty, tx = candidates[self.rng.integers(0, len(candidates))]
+                            new_grid[ty, tx] = GUILD
+
+                elif cell == GUILD:
+                    # Guilds stabilize local economy
+                    if nb_food < 0.5 and self.rng.random() < 0.05:
+                        candidates = [(ny, nx) for (ny, nx), c in zip(nb, nb_cells) if c == EMPTY]
+                        if candidates:
+                            ty, tx = candidates[self.rng.integers(0, len(candidates))]
+                            new_grid[ty, tx] = FOOD
+                            new_food[ty, tx] += 0.5
+                    # Guilds also increase chance of buildings emerging nearby
+                    if self.rng.random() < 0.02:
+                        candidates = [(ny, nx) for (ny, nx), c in zip(nb, nb_cells) if c == EMPTY]
+                        if candidates:
+                            ty, tx = candidates[self.rng.integers(0, len(candidates))]
+                            new_grid[ty, tx] = BUILDING
+
+                # starvation collapse (if local food is zero and high density)
+                if (cell in (MALE, FEMALE, BABY, WORKER)) and nb_food <= 0.0 and nb_density > 0.6 and self.rng.random() < 0.05:
+                    new_grid[y, x] = EMPTY
+
+        self.grid = new_grid
+        self.age_grid = new_age
+        self.food_stock = new_food
+        self.tick += 1
+
+    def render_image(self):
+        H, W = self.grid.shape
+        img = np.zeros((H, W, 3), dtype=np.uint8)
+        mapping = {
+            EMPTY: "EMPTY", MALE: "MALE", FEMALE: "FEMALE", BABY: "BABY", WORKER: "WORKER",
+            BUILDING: "BUILDING", SHOP: "SHOP", ROAD: "ROAD", FOREST: "FOREST", FOOD: "FOOD",
+            TEACHER: "TEACHER", GUILD: "GUILD"
+        }
+        for val, name in mapping.items():
+            rgb = COLORS[name]
+            mask = (self.grid == val)
+            img[mask] = np.array(rgb, dtype=np.uint8)
+        return img
+
+def stream_sim(
+    width=64, height=64, seed=7,
+    male_init=120, female_init=120, teacher_init=6,
+    forest_fraction=0.20, food_fraction=0.05,
+    baby_age_ticks=8, override_sensitivity=0.60,
+    update_interval_sec=10, total_minutes=2
+):
+    # Initialize the sim
+    params = SimParams(
+        width=width, height=height,
+        male_init=male_init, female_init=female_init, teacher_init=teacher_init,
+        forest_fraction=forest_fraction, food_fraction=food_fraction,
+        baby_age_ticks=baby_age_ticks, override_sensitivity=override_sensitivity
+    )
+    sim = Civilization(params, seed=seed)
+
+    # Stats tracking
+    pop_series, build_series, road_series, shop_series, food_series = [], [], [], [], []
+    total_ticks = int((60 // max(1, update_interval_sec)) * total_minutes)
+
+    legend = "Blue=Male, Pink=Female, Yellow=Baby, LightBlue=Worker, Gray=Building, Orange=Shop, Black=Road, Green=Forest, Lime=Food, Purple=Teacher, Gray-Purple=Guild"
+
+    for _ in range(total_ticks):
+        # Advance a few internal ticks per UI update for visible growth
+        inner_ticks = max(1, update_interval_sec // 2)
+        for __ in range(inner_ticks):
+            sim.step()
+
+        img = sim.render_image()
+        g = sim.grid
+        pop_series.append(int(np.sum(np.isin(g, [MALE, FEMALE, BABY, WORKER]))))
+        build_series.append(int(np.sum(g == BUILDING)))
+        road_series.append(int(np.sum(g == ROAD)))
+        shop_series.append(int(np.sum(g == SHOP)))
+        food_series.append(int(np.sum(g == FOOD)))
+
+        text = (
+            f"Tick={sim.tick} | Pop={pop_series[-1]} | Buildings={build_series[-1]} | Roads={road_series[-1]} | Shops={shop_series[-1]} | FoodCells={food_series[-1]}\n"
+            f"Artifact={ARTIFACT} | Author={AUTHOR}\n"
+            f"Legend: {legend}"
+        )
+        yield img, text
+        time.sleep(update_interval_sec)
+
+    # Seal & log at the end of the stream
+    summary = {
+        "tick_final": sim.tick,
+        "pop_final": pop_series[-1] if pop_series else 0,
+        "buildings_final": build_series[-1] if build_series else 0,
+        "roads_final": road_series[-1] if road_series else 0,
+        "shops_final": shop_series[-1] if shop_series else 0,
+        "food_cells_final": food_series[-1] if food_series else 0,
+        "width": int(width), "height": int(height),
+        "teacher_init": int(teacher_init),
+        "update_interval_sec": int(update_interval_sec),
+        "total_minutes": int(total_minutes),
+    }
+    seal = sha512_str(json.dumps(summary, sort_keys=True))
+    prov = {
+        "artifact": ARTIFACT,
+        "author": AUTHOR,
+        "registry": REGISTRY,
+        "timestamp": int(time.time()),
+        "params": {
+            "width": width, "height": height, "seed": seed,
+            "male_init": male_init, "female_init": female_init, "teacher_init": teacher_init,
+            "forest_fraction": forest_fraction, "food_fraction": food_fraction,
+            "baby_age_ticks": baby_age_ticks, "override_sensitivity": override_sensitivity,
+            "update_interval_sec": update_interval_sec, "total_minutes": total_minutes
+        },
+        "summary": summary,
+        "sha512": seal
+    }
+    try:
+        with open("provenance.jsonl", "a") as f:
+            f.write(json.dumps(prov) + "\n")
+    except Exception:
+        pass
+
+# =========================
+# Gradio UI (single screen)
+# =========================
+with gr.Blocks(title="RFT Conscious Civilization Simulator (Teachers)") as demo:
+    gr.Markdown(
+        "# RFT Conscious Civilization Simulator\n"
+        "Single-screen live grid. Conscious math rules (male+female=baby → worker → building/road/food → shops) grow villages into cities.\n"
+        "Purple Teacher agents guide life, spawn guilds, and stabilize growth.\n"
+        "Authored by Liam Grinstead. Each session is sealed for falsifiability."
+    )
+
+    with gr.Row():
+        width = gr.Slider(32, 128, value=64, step=8, label="Grid width")
+        height = gr.Slider(32, 128, value=64, step=8, label="Grid height")
+        seed = gr.Number(value=7, label="Seed", precision=0)
+
+    with gr.Row():
+        male_init = gr.Slider(20, 300, value=120, step=10, label="Initial males")
+        female_init = gr.Slider(20, 300, value=120, step=10, label="Initial females")
+        teacher_init = gr.Slider(1, 30, value=6, step=1, label="Initial teachers")
+
+    with gr.Row():
+        forest_fraction = gr.Slider(0.0, 0.6, value=0.20, step=0.02, label="Forest fraction")
+        food_fraction = gr.Slider(0.0, 0.3, value=0.05, step=0.01, label="Food fraction")
+        baby_age_ticks = gr.Slider(4, 20, value=8, step=1, label="Baby→Worker ticks")
+        override_sensitivity = gr.Slider(0.3, 0.9, value=0.60, step=0.05, label="Conscious override sensitivity")
+
+    with gr.Row():
+        update_interval_sec = gr.Slider(2, 20, value=10, step=1, label="Update cadence (seconds)")
+        total_minutes = gr.Slider(1, 10, value=2, step=1, label="Session duration (minutes)")
+
+    start_btn = gr.Button("Start live civilization")
+    img_out = gr.Image(type="numpy", label="Live grid", streaming=True)
+    text_out = gr.Textbox(label="Summary (streaming)", lines=4)
+
+    start_btn.click(
+        stream_sim,
+        inputs=[width, height, seed, male_init, female_init, teacher_init, forest_fraction, food_fraction, baby_age_ticks, override_sensitivity, update_interval_sec, total_minutes],
+        outputs=[img_out, text_out]
+    )
+
+if __name__ == "__main__":
+    demo.launch()