File size: 5,497 Bytes
d997548 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 | #!/usr/bin/env python3
"""
R5-compliant DNA Kernel.
100 chromosomes × 4 genes = 400 regulatory parameters per cell.
10 functional groups (each 10 chromosomes):
0: language
1: math
2: code
3: science
4: sensory
5: reasoning
6: memory
7: coordination
8: adaptation
9: growth
4 genes per chromosome (per R5 Section 3.5):
a = activation
s = sensitivity
p = persistence
pi = plasticity
Maps (D_c, K_c, u_c) -> {route, grow, split, retain}
"""
import hashlib
import json
import random
from dataclasses import dataclass, field, asdict
from pathlib import Path
from typing import Optional
N_CHROMOSOMES = 100
N_GENES = 4
GENE_NAMES = ["a", "s", "p", "pi"]
GROUPS = [
"language", "math", "code", "science", "sensory",
"reasoning", "memory", "coordination", "adaptation", "growth",
]
@dataclass
class DNA:
"""DNA of one cell. 100 chromosomes x 4 genes."""
cell_id: str
genes: list = field(default_factory=list) # shape [100][4]
generation: int = 0
parent_id: Optional[str] = None
mutations: int = 0
signature: str = ""
def __post_init__(self):
if not self.genes:
self.genes = [[0.5, 0.5, 0.5, 0.5] for _ in range(N_CHROMOSOMES)]
if not self.signature:
self.signature = self._compute_signature()
def _compute_signature(self) -> str:
raw = json.dumps(self.genes, sort_keys=True).encode()
return hashlib.sha256(raw).hexdigest()[:32]
def random_dna(cell_id: str, seed: int = 42) -> DNA:
rng = random.Random(seed)
genes = [[rng.random() for _ in range(N_GENES)] for _ in range(N_CHROMOSOMES)]
return DNA(cell_id=cell_id, genes=genes, generation=0)
def mutate_gene(g: float, rate: float = 0.01) -> float:
"""Small mutation; clamped to [0,1]."""
delta = random.uniform(-rate, rate)
return max(0.0, min(1.0, g + delta))
def mutate_dna(dna: DNA, rate: float = 0.01) -> DNA:
"""Copy with small random changes (used on split)."""
new_genes = [[mutate_gene(g, rate) for g in row] for row in dna.genes]
new = DNA(
cell_id=dna.cell_id + "_m" + str(dna.mutations + 1),
genes=new_genes,
generation=dna.generation + 1,
parent_id=dna.cell_id,
mutations=dna.mutations + 1,
)
return new
def group_mean(dna: DNA, group_idx: int, gene_idx: int) -> float:
"""Mean of a specific gene across the 10 chromosomes of one group."""
start = group_idx * 10
end = start + 10
vals = [dna.genes[i][gene_idx] for i in range(start, end)]
return sum(vals) / len(vals)
def signal_route(dna: DNA) -> float:
"""Probability of routing to this cell. Mean of 'a' gene across all groups."""
return sum(dna.genes[i][0] for i in range(N_CHROMOSOMES)) / N_CHROMOSOMES
def signal_grow(dna: DNA) -> float:
"""Readiness to grow. High plasticity (pi) + low persistence (p)."""
pi = sum(dna.genes[i][3] for i in range(N_CHROMOSOMES)) / N_CHROMOSOMES
p = sum(dna.genes[i][2] for i in range(N_CHROMOSOMES)) / N_CHROMOSOMES
return max(0.0, min(1.0, pi - p + 0.5))
def signal_split(dna: DNA, S: float, s_star: float = 0.85) -> float:
"""Readiness to split. Driven by S vs S* + sensitivity (s)."""
s = sum(dna.genes[i][1] for i in range(N_CHROMOSOMES)) / N_CHROMOSOMES
return max(0.0, min(1.0, (S - s_star) + s * 0.2))
def signal_retain(dna: DNA) -> float:
"""Readiness to retain (freeze). High persistence (p) + low plasticity (pi)."""
p = sum(dna.genes[i][2] for i in range(N_CHROMOSOMES)) / N_CHROMOSOMES
pi = sum(dna.genes[i][3] for i in range(N_CHROMOSOMES)) / N_CHROMOSOMES
return max(0.0, min(1.0, p - pi + 0.5))
def decide(dna: DNA, S: float, S_star: float = 0.85,
t_consecutive: int = 3) -> dict:
"""
(D_c, K_c, u_c) -> {route, grow, split, retain}
Priority-based decision per R5 Section 3.5.
Priority order (per R5):
1. split - if S >= S* sustained (handled by caller's S_history)
2. retain - if persistence high (frozen state)
3. grow - if plasticity high and not saturated
4. route - default behavior
"""
route = signal_route(dna)
grow = signal_grow(dna)
split = signal_split(dna, S, S_star)
retain = signal_retain(dna)
signals = {"route": route, "grow": grow, "split": split, "retain": retain}
# Priority-based decision (R5 Section 3.5)
if S >= S_star:
decision = "split"
elif retain > 0.7:
decision = "retain"
elif grow > 0.6:
decision = "grow"
else:
decision = "route"
signals["decision"] = decision
return signals
def save_dna(dna: DNA, path: Path):
path = Path(path)
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(json.dumps(asdict(dna), indent=2))
def load_dna(path: Path) -> DNA:
return DNA(**json.loads(Path(path).read_text()))
if __name__ == "__main__":
dna = random_dna("cell-0001", seed=42)
print(f"DNA cell: {dna.cell_id}")
print(f"Signature: {dna.signature}")
print(f"Genes[0][0:4]: {dna.genes[0]}")
print(f"Genes[50][0:4]: {dna.genes[50]}")
print()
for S in [0.5, 0.7, 0.85, 0.95]:
d = decide(dna, S)
print(f"S={S:.2f} -> route={d['route']:.3f} grow={d['grow']:.3f} "
f"split={d['split']:.3f} retain={d['retain']:.3f} "
f"=> {d['decision'].upper()}")
print()
m = mutate_dna(dna, rate=0.05)
print(f"Mutated: {m.cell_id} (generation {m.generation})")
|