File size: 4,315 Bytes
76b78ee | 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 | """Cross-domain pattern synthesis over memory strands (journalism suite 4).
The owner's closed-loop insight: every domain sits in one system, so a rung
(number, year, name) or theme repeated across UNRELATED domains is a lead.
The suite finds the overlap; the human decides whether the connection is
causal, coincidental, or symbolic. Cards carry the base-rate caveat so a
repeated number is never auto-promoted to a conclusion.
Basis: helix rung model (research/helix.py) + memory skill's cross-domain
reinforcement doctrine (tiny-model-memory).
Usage:
from research.patterns import CrossDomainPatterns
p = CrossDomainPatterns()
p.add_strand("economics", "the 1929 crash... gold standard...")
p.add_strand("religion", "Genesis... serpent... 1929...")
p.report()
"""
import re
from collections import defaultdict
from research.helix import rungs
THEMES = [
"serpent", "snake", "eye", "pyramid", "coin", "flood", "plague", "fire",
"tower", "gate", "seal", "crown", "star", "dove", "wolf", "mirror",
"key", "blood", "gold", "iron", "wall", "circle", "garden", "beast",
"mark", "number", "trumpet", "scroll", "angel", "dragon",
]
_NAME = re.compile(r"\b[A-Z][a-z]{2,20}(?:\s+[A-Z][a-z]{2,20}){0,2}\b")
class CrossDomainPatterns:
def __init__(self):
self.strands = [] # list of {"domain", "text"}
def add_strand(self, domain, text):
self.strands.append({"domain": domain, "text": text})
def domains(self):
return sorted({s["domain"] for s in self.strands})
def shared_rungs(self):
"""Rungs (numbers/years/times/names) present in >=2 different domains."""
by_rung = defaultdict(dict)
for s in self.strands:
vals = set(rungs(s["text"]))
for v in vals:
by_rung[v][s["domain"]] = by_rung[v].get(s["domain"], 0) + 1
out = []
for v, doms in by_rung.items():
if len(doms) >= 2:
out.append({"rung": v, "domains": sorted(doms),
"strength": min(doms.values())})
return sorted(out, key=lambda c: -c["strength"])
def theme_overlap(self):
"""Themes present in >=2 different domains."""
by_theme = defaultdict(set)
for s in self.strands:
low = s["text"].lower()
for t in THEMES:
if t in low:
by_theme[t].add(s["domain"])
return [{"theme": t, "domains": sorted(d)}
for t, d in by_theme.items() if len(d) >= 2]
def names(self, min_domains=2):
"""Proper-noun co-occurrence across domains (loose entity bridge)."""
by_name = defaultdict(set)
for s in self.strands:
for m in _NAME.finditer(s["text"]):
by_name[m.group(0)].add(s["domain"])
return [{"name": n, "domains": sorted(d)}
for n, d in by_name.items() if len(d) >= min_domains]
def report(self):
lines = ["# Cross-Domain Pattern Synthesis", ""]
lines.append(f"domains: {', '.join(self.domains())}")
lines.append("")
lines.append("## Shared rungs (numbers/years/times)")
sr = self.shared_rungs()
for c in sr[:20]:
lines.append(f"- `{c['rung']}` (strength {c['strength']}) appears in "
f"{', '.join(c['domains'])}")
lines.append(" - LEAD: check whether causal, coincidental, or symbolic")
if not sr:
lines.append("- no cross-domain rungs")
lines.append("")
lines.append("## Theme overlap")
for c in self.theme_overlap()[:20]:
lines.append(f"- '{c['theme']}' in {', '.join(c['domains'])}")
lines.append(" - LEAD: base-rate check first; repeated themes are "
"common in text")
if not self.theme_overlap():
lines.append("- no cross-domain themes")
lines.append("")
lines.append("## Name bridges")
for c in self.names()[:20]:
lines.append(f"- '{c['name']}' in {', '.join(c['domains'])}")
if not self.names():
lines.append("- no cross-domain name bridges")
lines.append("")
lines.append("_Every card above is a LEAD, never a verdict._")
return "\n".join(lines)
|