Spaces:
Paused
Paused
| """ | |
| Report Builder — Generates markdown reports from research registries. | |
| Produces: | |
| - RESEARCH_CATALOG.md — Full catalog of questions, hypotheses, evidence | |
| - EVIDENCE_MATRIX.md — Overview of evidence status per question | |
| - OPEN_QUESTIONS.md — All unanswered questions | |
| - CLAIM_REGISTER.md — All claims with status | |
| - DISSERTATION_MAP.md — Dissertation chapter structure mapped to research | |
| """ | |
| from __future__ import annotations | |
| import json | |
| from datetime import datetime | |
| from pathlib import Path | |
| from typing import Any | |
| from .registry import REPO_ROOT, ResearchQuestion, ResearchRegistry | |
| GENERATED_DIR = REPO_ROOT / "research" / "generated" | |
| EVIDENCE_DIR = REPO_ROOT / "research" / "registry" / "evidence" | |
| class EvidenceRecord: | |
| """Typed wrapper for an EVID-*.json record.""" | |
| def __init__(self, data: dict[str, Any]) -> None: | |
| self.evidence_id = data.get("evidence_id", "") | |
| self.experiment_id = data.get("experiment_id") | |
| self.claim_id = data.get("claim_id") | |
| self.hypothesis_id = data.get("hypothesis_id") | |
| self.status = data.get("status", "untested") | |
| self.result_summary = data.get("result_summary", "") | |
| class ReportBuilder: | |
| """Generates markdown reports from the research registry and evidence records.""" | |
| def __init__(self, registry: ResearchRegistry): | |
| self.registry = registry | |
| self._evidence_records: dict[str, EvidenceRecord] = {} | |
| self._load_evidence_records() | |
| def _load_evidence_records(self) -> None: | |
| """Load all EVID-*.json files from the evidence directory.""" | |
| self._evidence_records = {} | |
| if not EVIDENCE_DIR.exists(): | |
| return | |
| for path in sorted(EVIDENCE_DIR.glob("EVID-*.json")): | |
| try: | |
| data = json.loads(path.read_text(encoding="utf-8")) | |
| ev = EvidenceRecord(data) | |
| if ev.evidence_id: | |
| self._evidence_records[ev.evidence_id] = ev | |
| except Exception: | |
| continue | |
| def _evidence_for_question(self, question_id: str) -> set[str]: | |
| """Return all evidence IDs linked to a research question. | |
| Links are followed via hypothesis_id and claim_id in the evidence | |
| records, matching the canonical B5D-SEF data model. | |
| """ | |
| result: set[str] = set() | |
| hypotheses = self.registry.hypotheses_for_question(question_id) | |
| hypothesis_ids = {h.id for h in hypotheses} | |
| claims = self.registry.claims_for_question(question_id) | |
| claim_ids = {c.id for c in claims} | |
| for ev in self._evidence_records.values(): | |
| if ev.hypothesis_id in hypothesis_ids: | |
| result.add(ev.evidence_id) | |
| if ev.claim_id in claim_ids: | |
| result.add(ev.evidence_id) | |
| return result | |
| def _evidence_for_hypothesis(self, hypothesis_id: str) -> set[str]: | |
| return { | |
| ev.evidence_id | |
| for ev in self._evidence_records.values() | |
| if ev.hypothesis_id == hypothesis_id | |
| } | |
| def _evidence_for_claim(self, claim_id: str) -> set[str]: | |
| return { | |
| ev.evidence_id | |
| for ev in self._evidence_records.values() | |
| if ev.claim_id == claim_id | |
| } | |
| def build_research_catalog(self) -> str: | |
| """Generate a complete research catalog.""" | |
| lines = [ | |
| "# Brain-5D Research Catalog", | |
| "", | |
| f"*Generiert am {datetime.now().strftime('%Y-%m-%d')}*", | |
| "", | |
| "## Übersicht", | |
| "", | |
| f"- **Forschungsfragen:** {len(self.registry.questions)}", | |
| f"- **Hypothesen:** {len(self.registry.hypotheses)}", | |
| f"- **Claims:** {len(self.registry.claims)}", | |
| f"- **Literaturquellen:** {len(self.registry.sources)}", | |
| "", | |
| "---", | |
| "", | |
| ] | |
| domains: dict[str, list[ResearchQuestion]] = {} | |
| for q in self.registry.questions.values(): | |
| domains.setdefault(q.domain, []).append(q) | |
| for domain in sorted(domains.keys()): | |
| lines.extend([f"## {domain}", ""]) | |
| for q in domains[domain]: | |
| hypotheses = self.registry.hypotheses_for_question(q.id) | |
| claims = self.registry.claims_for_question(q.id) | |
| sources = self.registry.sources_for_question(q.id) | |
| lines.extend( | |
| [ | |
| f"### {q.id}", | |
| "", | |
| f"**Frage:** {q.question}", | |
| "", | |
| f"**Status:** {q.status}", | |
| f"**Relevanz:** {q.relevance}", | |
| "", | |
| ] | |
| ) | |
| if q.answer.current: | |
| lines.extend( | |
| [ | |
| "**Aktuelle Antwort:**", | |
| "", | |
| f"> {q.answer.current}", | |
| "", | |
| f"*Konfidenz: {q.answer.confidence}*", | |
| "", | |
| ] | |
| ) | |
| # Collect evidence IDs from hypotheses and claims linked to this question | |
| question_evidence = self._evidence_for_question(q.id) | |
| if hypotheses: | |
| lines.append("**Hypothesen:**") | |
| for h in hypotheses: | |
| h_evidence = sorted(self._evidence_for_hypothesis(h.id)) | |
| ev_tag = ( | |
| f" — Evidenz: {', '.join(h_evidence)}" if h_evidence else "" | |
| ) | |
| lines.append( | |
| f"- `{h.id}`: {h.hypothesis} *({h.status})*{ev_tag}" | |
| ) | |
| lines.append("") | |
| if claims: | |
| lines.append("**Claims:**") | |
| for c in claims: | |
| c_evidence = sorted(self._evidence_for_claim(c.id)) | |
| ev_tag = ( | |
| f" — Evidenz: {', '.join(c_evidence)}" if c_evidence else "" | |
| ) | |
| lines.append( | |
| f"- `{c.id}`: {c.claim} *({c.status}, {c.confidence})*{ev_tag}" | |
| ) | |
| lines.append("") | |
| if sources: | |
| lines.append("**Literatur:**") | |
| for s in sources: | |
| lines.append( | |
| f"- `{s.source_id}`: {s.authors[0]} et al. ({s.year})" | |
| ) | |
| lines.append("") | |
| if question_evidence: | |
| lines.append( | |
| f"**Evidenzen:** {', '.join(sorted(question_evidence))}" | |
| ) | |
| lines.append("") | |
| lines.append("---") | |
| lines.append("") | |
| return "\n".join(lines) | |
| def build_evidence_matrix(self) -> str: | |
| """Generate an evidence matrix showing status per question.""" | |
| lines = [ | |
| "# Brain-5D Evidence Matrix", | |
| "", | |
| f"*Generiert am {datetime.now().strftime('%Y-%m-%d')}*", | |
| "", | |
| "| Forschungsfrage | Hypothese | Literatur | Experimente | Evidenz | Antwort |", | |
| "|----------------|-----------|-----------|-------------|---------|---------|", | |
| ] | |
| for q in self.registry.questions.values(): | |
| hypotheses = self.registry.hypotheses_for_question(q.id) | |
| sources = self.registry.sources_for_question(q.id) | |
| claims = self.registry.claims_for_question(q.id) | |
| h_text = ", ".join(f"`{h.id}`" for h in hypotheses) or "—" | |
| s_text = str(len(sources)) | |
| c_text = ", ".join(f"`{c.id}`" for c in claims) if claims else "—" | |
| question_evidence = sorted(self._evidence_for_question(q.id)) | |
| ev_text = ( | |
| ", ".join(f"`{e}`" for e in question_evidence) | |
| if question_evidence | |
| else "—" | |
| ) | |
| answer_text = q.answer.confidence if q.answer.current else "offen" | |
| lines.append( | |
| f"| `{q.id}` | {h_text} | {s_text} | {c_text} | {ev_text} | {answer_text} |" | |
| ) | |
| supported = sum( | |
| 1 for c in self.registry.claims.values() if c.status == "supported" | |
| ) | |
| refuted = sum(1 for c in self.registry.claims.values() if c.status == "refuted") | |
| untested = sum( | |
| 1 for c in self.registry.claims.values() if c.status == "untested" | |
| ) | |
| inconclusive = sum( | |
| 1 for c in self.registry.claims.values() if c.status == "inconclusive" | |
| ) | |
| lines.extend( | |
| [ | |
| "", | |
| "## Zusammenfassung", | |
| "", | |
| "| Status | Anzahl |", | |
| "|--------|--------|", | |
| f"| ✅ Supported | {supported} |", | |
| f"| ❌ Refuted | {refuted} |", | |
| f"| 🔄 Inconclusive | {inconclusive} |", | |
| f"| ⬜ Untested | {untested} |", | |
| f"| **Gesamt** | **{len(self.registry.claims)}** |", | |
| "", | |
| "---", | |
| "*Automatisch generiert — Theorie, Beobachtung und Interpretation sind strikt getrennt.*", | |
| ] | |
| ) | |
| return "\n".join(lines) | |
| def build_open_questions(self) -> str: | |
| """Generate a document listing all unanswered research questions.""" | |
| lines = [ | |
| "# Brain-5D Open Questions", | |
| "", | |
| f"*Generiert am {datetime.now().strftime('%Y-%m-%d')}*", | |
| "", | |
| "Die folgenden Forschungsfragen sind noch offen und warten auf experimentelle Evidenz.", | |
| "", | |
| ] | |
| unresolved = [ | |
| question | |
| for question in self.registry.questions.values() | |
| if question.status in {"open", "in_progress", "inconclusive"} | |
| ] | |
| for q in unresolved: | |
| lines.extend( | |
| [ | |
| f"## {q.id}", | |
| "", | |
| f"**Domäne:** {q.domain}", | |
| "", | |
| f"**Frage:** {q.question}", | |
| "", | |
| f"**Relevanz:** {q.relevance}", | |
| "", | |
| ] | |
| ) | |
| sources = self.registry.sources_for_question(q.id) | |
| if sources: | |
| lines.append("**Literatur:**") | |
| for s in sources: | |
| lines.append(f"- `{s.source_id}`: {s.authors[0]} et al. ({s.year})") | |
| lines.append("") | |
| hypotheses = self.registry.hypotheses_for_question(q.id) | |
| if hypotheses: | |
| lines.append("**Hypothesen:**") | |
| for h in hypotheses: | |
| lines.append(f"- `{h.id}`: {h.hypothesis}") | |
| lines.append("") | |
| lines.append("---") | |
| lines.append("") | |
| lines.append(f"*Insgesamt {len(unresolved)} offene Fragen.*") | |
| return "\n".join(lines) | |
| def build_claim_register(self) -> str: | |
| """Generate a register of all scientific claims.""" | |
| lines = [ | |
| "# Brain-5D Claim Register", | |
| "", | |
| f"*Generiert am {datetime.now().strftime('%Y-%m-%d')}*", | |
| "", | |
| "| Claim | Status | Konfidenz | Evidenzen | Experimente |", | |
| "|-------|--------|-----------|-----------|-------------|", | |
| ] | |
| for c in self.registry.claims.values(): | |
| icon = { | |
| "supported": "✅", | |
| "refuted": "❌", | |
| "inconclusive": "🔄", | |
| "untested": "⬜", | |
| }.get(c.status, "⬜") | |
| evidence_count = len(self._evidence_for_claim(c.id)) | |
| lines.append( | |
| f"| `{c.id}`: {c.claim[:80]}... | {icon} {c.status} | " | |
| f"{c.confidence} | {evidence_count} | {len(c.experiments)} |" | |
| ) | |
| lines.append("") | |
| return "\n".join(lines) | |
| def build_dissertation_map(self) -> str: | |
| """Generate a dissertation structure mapped to research entities.""" | |
| chapters: dict[str, dict[str, Any]] = { | |
| "Kapitel 1 – Theorie und Grundlagen": { | |
| "questions": ["RQ-SNN-001", "RQ-SNN-002", "RQ-DET-001"], | |
| "sources": [ | |
| "SRC-IZHIKEVICH-2003", | |
| "SRC-GERSTNER-2014", | |
| "SRC-MAASS-1997", | |
| ], | |
| "description": "Einführung in SNN-Theorie, Izhikevich-Modell, deterministische Dynamik", | |
| }, | |
| "Kapitel 2 – Plastizität und Lernen": { | |
| "questions": [ | |
| "RQ-SNN-004", | |
| "RQ-SNN-005", | |
| "RQ-STDP-001", | |
| "RQ-STDP-002", | |
| "RQ-HOM-001", | |
| "RQ-HOM-002", | |
| ], | |
| "sources": [ | |
| "SRC-SONG-ABBOTT-2000", | |
| "SRC-BI-POO-1998", | |
| "SRC-TURRIGIANO-2008", | |
| "SRC-HEBB-1949", | |
| ], | |
| "description": "STDP, Homeostase, Interaktion, Lernleistung", | |
| }, | |
| "Kapitel 3 – 5D-Raum und Topologie": { | |
| "questions": ["RQ-5D-001", "RQ-5D-002", "RQ-5D-003", "RQ-5D-004"], | |
| "sources": [], | |
| "description": "Dimensionsablation, Signalpropagation, Modularität, Informationstheorie", | |
| }, | |
| "Kapitel 4 – Persistenz und Speicherung": { | |
| "questions": [ | |
| "RQ-STORAGE-001", | |
| "RQ-STORAGE-002", | |
| "RQ-STORAGE-003", | |
| "RQ-STORAGE-004", | |
| ], | |
| "sources": [], | |
| "description": ".b5d-Format, verlustfreie Serialisierung, Speicherdichte, Skalierung", | |
| }, | |
| "Kapitel 5 – Selbstorganisation": { | |
| "questions": ["RQ-SELF-001", "RQ-SELF-002", "RQ-STRUCT-001"], | |
| "sources": [], | |
| "description": "Emergenz, Clusterbildung, Pruning, Sprouting", | |
| }, | |
| "Kapitel 6 – Skalierung": { | |
| "questions": ["RQ-SCALE-001"], | |
| "sources": ["SRC-MARKRAM-2015"], | |
| "description": "Skalierung von 5k auf Millionen Neuronen", | |
| }, | |
| "Kapitel 7 – Gedächtnis und Embodiment": { | |
| "questions": ["RQ-MEM-001", "RQ-EMB-001", "RQ-LLM-001"], | |
| "sources": [], | |
| "description": "Synaptisches Gedächtnis, Sensor-Aktor-Schleife, Language Organ", | |
| }, | |
| "Kapitel 8 – Autorenschaft und Epistemologie": { | |
| "questions": ["RQ-ETH-001", "RQ-ETH-002", "RQ-EPIST-001"], | |
| "sources": [], | |
| "description": "Verteilte Autorenschaft, Kontrollverlust, maschinelle Erkenntnis", | |
| }, | |
| } | |
| lines = [ | |
| "# Brain-5D Dissertation Map", | |
| "", | |
| f"*Generiert am {datetime.now().strftime('%Y-%m-%d')}*", | |
| "", | |
| "Diese Karte zeigt, wie die Forschungsergebnisse von Brain-5D in eine", | |
| "Dissertationsstruktur eingeordnet werden können.", | |
| "", | |
| ] | |
| for chapter, info in chapters.items(): | |
| lines.extend([f"## {chapter}", "", info["description"], ""]) | |
| questions = [ | |
| self.registry.questions[qid] | |
| for qid in info["questions"] | |
| if qid in self.registry.questions | |
| ] | |
| if questions: | |
| lines.append("**Forschungsfragen:**") | |
| for q in questions: | |
| lines.append(f"- `{q.id}`: {q.question[:80]}... *({q.status})*") | |
| lines.append("") | |
| sources = [ | |
| self.registry.sources[sid] | |
| for sid in info["sources"] | |
| if sid in self.registry.sources | |
| ] | |
| if sources: | |
| lines.append("**Literatur:**") | |
| for s in sources: | |
| lines.append(f"- `{s.source_id}`: {s.authors[0]} et al. ({s.year})") | |
| lines.append("") | |
| lines.append("---") | |
| lines.append("") | |
| return "\n".join(lines) | |
| def write_all(self, output_dir: Path | None = None) -> dict[str, Path]: | |
| """Generate and write all reports. Returns dict of name -> path.""" | |
| out = output_dir or GENERATED_DIR | |
| out.mkdir(parents=True, exist_ok=True) | |
| reports = { | |
| "RESEARCH_CATALOG.md": self.build_research_catalog, | |
| "EVIDENCE_MATRIX.md": self.build_evidence_matrix, | |
| "OPEN_QUESTIONS.md": self.build_open_questions, | |
| "CLAIM_REGISTER.md": self.build_claim_register, | |
| "DISSERTATION_MAP.md": self.build_dissertation_map, | |
| } | |
| paths: dict[str, Path] = {} | |
| for name, builder in reports.items(): | |
| path = out / name | |
| path.write_text(builder(), encoding="utf-8") | |
| paths[name] = path | |
| return paths | |