feat: hard-sync reasoning modules

concept_graph.py

@@ -0,0 +1,31 @@
+import json, os, numpy as np, faiss
+from pathlib import Path
+from typing import Dict, List, Tuple, Any
+
+class ConceptNode:
+    def __init__(self, cid, label, embedding, confidence, edges=None):
+        self.cid, self.label, self.embedding, self.confidence, self.edges = cid, label, embedding, confidence, edges or []
+    def to_dict(self):
+        return {"cid": self.cid, "label": self.label, "embedding": self.embedding.tolist(), "confidence": self.confidence, "edges": self.edges}
+    @staticmethod
+    def from_dict(d):
+        return ConceptNode(int(d["cid"]), str(d["label"]), np.array(d["embedding"], dtype=np.float32), float(d["confidence"]), [tuple(e) for e in d.get("edges", [])])
+
+class ConceptGraph:
+    def __init__(self, dim=768, persist_dir="data/concept_graph"):
+        self.dim, self.persist_dir = dim, Path(persist_dir)
+        self.persist_dir.mkdir(parents=True, exist_ok=True)
+        self.index = faiss.IndexFlatL2(dim)
+        self._nodes: Dict[int, ConceptNode] = {}
+    def add_node(self, label, embedding, confidence, edges=None):
+        vec = embedding.astype(np.float32)
+        vec /= np.linalg.norm(vec)
+        self.index.add(np.expand_dims(vec, 0))
+        cid = self.index.ntotal - 1
+        node = ConceptNode(cid, label, vec, confidence, edges)
+        self._nodes[cid] = node
+        return cid
+    def persist(self):
+        with (self.persist_dir / "concepts.json").open("w") as f:
+            json.dump([n.to_dict() for n in self._nodes.values()], f, indent=2)
+        faiss.write_index(self.index, str(self.persist_dir / "faiss.index"))

high_precision.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+import math
+from decimal import Decimal, getcontext, localcontext
+from typing import Union
+getcontext().prec = 60
+Number = Union[float, Decimal]
+def to_decimal(x: Number) -> Decimal:
+    return x if isinstance(x, Decimal) else Decimal(str(x))
+def sqrt(x: Number) -> Decimal:
+    with localcontext() as ctx:
+        ctx.prec = getcontext().prec
+        return to_decimal(x).sqrt()
+def exp(x: Number) -> Decimal:
+    with localcontext() as ctx:
+        ctx.prec = getcontext().prec
+        return to_decimal(x).exp()
+def log(x: Number, base: Number = math.e) -> Decimal:
+    with localcontext() as ctx:
+        ctx.prec = getcontext().prec
+        d = to_decimal(x).ln()
+        return d / to_decimal(base).ln() if base != math.e else d

science_reasoner.py

@@ -0,0 +1,16 @@
+import numpy as np, sympy as sp
+class ScienceReasoner:
+    def __init__(self, graph): self.graph = graph
+    def infer(self, propositions, steps, max_depth=10):
+        premise_cids = [self.graph.add_node(p.text, p.embedding, p.confidence) for p in propositions]
+        current_cids, depth = premise_cids, 0
+        while depth < max_depth:
+            node_a = self.graph.get_node(current_cids[0])
+            node_b = self.graph.get_node(current_cids[1] if len(current_cids)>1 else current_cids[0])
+            new_conf = node_a.confidence * node_b.confidence
+            label = f"({node_a.label} AND {node_b.label})"
+            embed = (node_a.embedding + node_b.embedding) / 2.0
+            last_cid = self.graph.add_node(label, embed / np.linalg.norm(embed), new_conf)
+            current_cids = [last_cid] + current_cids
+            depth += 1
+        return self.graph.get_node(last_cid)