hypgraph 0.7.3__tar.gz → 0.7.5__tar.gz

{hypgraph-0.7.3 → hypgraph-0.7.5}/CHANGELOG.md

@@ -1,4 +1,29 @@
 # Changelog
+ 
+## 0.7.5 — 2026-10-28: a cited source is a line of support, and a finding of failure is not a fall
+
+- **A cited source is a line of support, and a succeeded run's "failed" outcome is a finding, not a fall.**
+  A knowledge claim that cites its sources (`cites` → source, or `derived_from` → source) read "no live
+  support · unverified" even after 0.7.4 counted bound results; the source is what such a claim rests on,
+  and its line is `external`. And a result with `outcome: failed` counted as a broken premise whatever its
+  run did: testers write "failed" for the code under test failing its spec (30 results in the challenge
+  records, 13 carrying checked claims that then read UNSUPPORTED — every support has fallen). A result a
+  succeeded run produced did happen; it falls only when there is no run or the run did not succeed.
+
+## 0.7.4 — 2026-10-28: a bound result is a line of support, and a relation word is read as the relation it names
+
+- **A bound result is a line of support.** A claim's standing counted only `supports` edges into it, so a claim
+  that derives from a result and binds its numbers to it by `measurements` read "no live support", evidence
+  "unverified" — 73 of 113 active claims in the challenge records, each with its result right there. The results a
+  claim derives from and the results its measurements bind now count as lines of support (each once; shared runs
+  or data still merge into one line), so the evidence profile is the result's — lab-recorded when the instrument
+  filed it — and `unsupported` means what it says.
+- **A relation word the grammar doesn't have is read as the relation it names.** "generated", "created", "wrote"
+  → `produced`; "ran", "executed" → `executes`; "test" → `tests`; "answer" → `answers`; "used", "reads" → `uses`;
+  "contradicts", "refutes" → `challenges`; and so on (`schema.REL_SYNONYMS`, one reading each), noted on the
+  link like a translation. A hypothesis "derived from" a claim or result is `motivated_by` it; an experiment
+  "derived from" a hypothesis `tests` it. The link refusals left in the runs after 0.7.3: an unknown relation
+  `generated`, `derived_from hypothesis → claim`.
 
 ## 0.7.3 — 2026-10-28: the refusal log sees everything — results, shape, links — and reads a link as the relation that joins
 

{hypgraph-0.7.3 → hypgraph-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.7.3
+Version: 0.7.5
 Summary: The evidence layer for AI research agents: a hash-chained research record that checks every claim as it is written and derives how well each is known.
 Project-URL: Homepage, https://hypgraph.com
 Project-URL: Documentation, https://hypgraph.com/engineers/

{hypgraph-0.7.3 → hypgraph-0.7.5}/src/hypgraph/__init__.py

@@ -16,7 +16,7 @@ Standing is derived on every read, never stored; every write is an event in a SH
 their numbers; reviews pin versions; independence is counted, not assumed. See https://hypgraph.com.
 """
 
-__version__ = "0.7.3"
+__version__ = "0.7.5"
 
 from .bundle import verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.7.3 → hypgraph-0.7.5}/src/hypgraph/derive.py

@@ -134,7 +134,11 @@ def fallen(s: Snap, nid: str) -> bool:
     if n["type"] == "run" and n["body"].get("state") in ("failed", "timeout", "cancelled", "interrupted"):
         return True
     if n["type"] == "result" and n["body"].get("outcome") == "failed":
-        return True
+        # "failed" means the measurement didn't happen. A result a succeeded run produced did happen: its author
+        # wrote "failed" for what it measured (the code under test failing its spec — 30 results in the challenge
+        # records, 13 carrying checked claims that then read UNSUPPORTED). That is a finding, not a fall.
+        run = producing_run(s, nid)
+        return not (run and s.nodes[run]["body"].get("state") == "succeeded")
     return False
 
 
@@ -349,7 +353,26 @@ def dependents(s: Snap, nid: str, limit: int = 500) -> list[tuple[str, str, int]
 
 
 def supporters(s: Snap, nid: str) -> list[dict]:
-    return [e for e in s.inn.get(nid, []) if e["rel"] == "supports"]
+    """What stands behind a node: every `supports` edge into it, and — for a claim — the results it is derived from,
+    the sources it derives from or cites, and the results its measurements bind (each once). A claim that binds its numbers to a result rests on that
+    result whether or not anyone also wrote `supports`; until 0.7.4 only the edge counted, and most honest claims
+    read "no live support" with their evidence "unverified"."""
+    out = [e for e in s.inn.get(nid, []) if e["rel"] == "supports"]
+    n = s.nodes.get(nid)
+    if n and n["type"] == "claim":
+        seen = {e["src"] for e in out}
+        for e in s.out.get(nid, []):
+            # a result it derives from, or a source it derives from or cites: what the claim rests on
+            if e["rel"] in ("derived_from", "cites") and e["dst"] in s.nodes and e["dst"] not in seen \
+                    and s.nodes[e["dst"]]["type"] in (("result", "source") if e["rel"] == "derived_from" else ("source",)):
+                seen.add(e["dst"])
+                out.append({"src": e["dst"], "rel": e["rel"], "dst": nid, "data": {}, "by": n["created_by"]})
+        for m in n["body"].get("measurements") or []:
+            rid = m.get("result") if isinstance(m, dict) else None
+            if rid and rid in s.nodes and s.nodes[rid]["type"] == "result" and rid not in seen:
+                seen.add(rid)
+                out.append({"src": rid, "rel": "measurement", "dst": nid, "data": {}, "by": n["created_by"]})
+    return out
 
 
 def at_risk(s: Snap, nid: str) -> list[str]:

{hypgraph-0.7.3 → hypgraph-0.7.5}/src/hypgraph/graph.py

@@ -31,7 +31,7 @@ from . import derive as D
 from . import refusals, store
 from .checks import claim_issues, value_issues
 from .policy import Policy
-from .schema import REPLICATION, RELS, SAME_TYPE, SYNONYMS, TRANSLATE, TYPES, VERDICTS
+from .schema import REL_SYNONYMS, REPLICATION, RELS, SAME_TYPE, SYNONYMS, TRANSLATE, TYPES, VERDICTS
 from .store import canon, now
 
 
@@ -462,14 +462,25 @@ class Graph:
     @staticmethod
     def _translate(s: D.Snap, src: str, rel: str, dst: str) -> tuple[str, str]:
         """A relation that can't join these two types, read as the one that says the same thing between them
-        (schema.TRANSLATE): the relation to apply and a note, or the given relation and ''."""
+        (schema.TRANSLATE), or a word the grammar doesn't have read as the relation it names (schema.REL_SYNONYMS):
+        the relation to apply and a note, or the given relation and ''."""
+        given = rel
+        if rel not in RELS:
+            word = str(rel or "").strip().lower().replace(" ", "_").replace("-", "_")
+            rel = REL_SYNONYMS.get(word, rel)
+            if rel in RELS and src in s.nodes and dst in s.nodes:
+                st, dt = s.nodes[src]["type"], s.nodes[dst]["type"]
+                srcs, dsts = RELS[rel]
+                if (st in srcs and dt in dsts) or (dt in srcs and st in dsts):
+                    return rel, (f"{s.nodes[src].get('code') or src} -{given}-> {s.nodes[dst].get('code') or dst} "
+                                 f"read as {rel}")
         if rel in RELS and src in s.nodes and dst in s.nodes:
             st, dt = s.nodes[src]["type"], s.nodes[dst]["type"]
             srcs, dsts = RELS[rel]
             if not (st in srcs and dt in dsts) and not (dt in srcs and st in dsts):
                 new = TRANSLATE.get((rel, st, dt))
                 if new:
-                    return new, (f"{s.nodes[src].get('code') or src} -{rel}-> {s.nodes[dst].get('code') or dst} "
+                    return new, (f"{s.nodes[src].get('code') or src} -{given}-> {s.nodes[dst].get('code') or dst} "
                                  f"read as {new} (a {st} {new.replace('_', ' ')} a {dt}; {rel} joins "
                                  f"{', '.join(sorted(srcs))} to {', '.join(sorted(dsts))})")
         return rel, ""

{hypgraph-0.7.3 → hypgraph-0.7.5}/src/hypgraph/schema.py

@@ -125,6 +125,25 @@ TRANSLATE: dict[tuple[str, str, str], str] = {
     ("part_of", "claim", "artifact"): "derived_from",
     ("supports", "decision", "hypothesis"): "based_on", ("supports", "decision", "claim"): "based_on",
     ("supports", "decision", "result"): "based_on",
+    ("derived_from", "hypothesis", "claim"): "motivated_by", ("derived_from", "hypothesis", "result"): "motivated_by",
+    ("derived_from", "experiment", "hypothesis"): "tests", ("derived_from", "question", "claim"): "motivated_by",
+}
+
+# A relation written as a word the grammar doesn't have — the run's own verb ("generated", "ran", "test") — read as
+# the relation it names. Only words with one reading.
+REL_SYNONYMS: dict[str, str] = {
+    "generated": "produced", "generates": "produced", "created": "produced", "creates": "produced",
+    "wrote": "produced", "writes": "produced", "produces": "produced", "output": "produced",
+    "ran": "executes", "runs": "executes", "executed": "executes", "execute": "executes", "performs": "executes",
+    "test": "tests", "tested": "tests", "testing": "tests", "answer": "answers", "answered": "answers",
+    "support": "supports", "supported": "supports", "challenge": "challenges", "challenged": "challenges",
+    "contradicts": "challenges", "refutes": "challenges", "derived": "derived_from", "derives_from": "derived_from",
+    "computed_from": "derived_from", "based": "based_on", "use": "uses", "used": "uses", "using": "uses",
+    "reads": "uses", "read": "uses", "cite": "cites", "cited": "cites", "citing": "cites", "replicate": "replicates",
+    "replicated": "replicates", "supersede": "supersedes", "superseded": "supersedes", "replaces": "supersedes",
+    "correct": "corrects", "corrected": "corrects", "require": "requires", "required": "requires",
+    "depends_on": "requires", "part": "part_of", "belongs_to": "part_of", "motivated": "motivated_by",
+    "rests": "rests_on", "works": "works_on", "blocked": "blocked_by", "settle": "settles", "settled": "settles",
 }
 
 SYNONYMS: dict[tuple[str, str], dict[str, str]] = {

hypgraph-0.7.5/tests/test_bound_support.py

@@ -0,0 +1,55 @@
+"""A result a claim derives from, or binds a measurement to, is a line of support; two bound results from one run are
+one line; a bound result that fell leaves the claim unsupported. 73 of 113 active claims in the challenge records
+read "no live support" beside the result they were bound to."""
+import pytest
+
+from hypgraph import Graph, Policy
+from hypgraph import derive as D
+
+
+@pytest.fixture
+def env():
+    g = Graph(policy=Policy(reviewers={"critic"}, instrument="lab"))
+    lead = g.author("lead")
+    inv = lead.investigation("Support", "Find out what a bound claim rests on.")["id"]
+    run = g.create(author="lab", type="run", inv=inv, fields={"kind": "lab", "name": "count", "state": "succeeded"})["id"]
+    r1 = g.create(author="lab", type="result", inv=inv, fields={"summary": "607 of 821 rows pass the check.",
+                  "values": {"rows": {"k": 607, "n": 821}}}, links=[{"rel": "produced", "from": run}])["id"]
+    r2 = g.create(author="lab", type="result", inv=inv, fields={"summary": "214 of 821 rows carry a comma.",
+                  "values": {"commas": {"k": 214, "n": 821}}}, links=[{"rel": "produced", "from": run}])["id"]
+    return g, inv, run, r1, r2
+
+
+def _state(g, nid):
+    return D.state(g.snapshot(), nid)
+
+
+def test_a_claim_bound_by_measurements_and_derived_from_is_supported_by_its_result(env):
+    g, inv, run, r1, r2 = env
+    c = g.author("analyst").add("claim", inv, statement="607 of 821 rows pass the check.", scope="corpus.csv's 821 rows.",
+                                measurements=[{"name": "rows", "result": r1, "key": "rows", "k": 607, "n": 821}],
+                                links=[{"rel": "derived_from", "to": r1}])
+    st = _state(g, c["id"])
+    assert st["independent_lines"] == 1 and st["evidence"] != "unverified" and not st["unsupported"]
+    assert "1 independent line of support" in st["sentence"]
+
+
+def test_two_bound_results_from_one_run_are_one_line_and_a_supports_edge_adds_none(env):
+    g, inv, run, r1, r2 = env
+    c = g.author("analyst").add("claim", inv, statement="607 of 821 rows pass and 214 of 821 carry a comma.",
+                                scope="corpus.csv's 821 rows.",
+                                measurements=[{"name": "rows", "result": r1, "key": "rows", "k": 607, "n": 821},
+                                              {"name": "commas", "result": r2, "key": "commas", "k": 214, "n": 821}])
+    assert _state(g, c["id"])["independent_lines"] == 1
+    g.author("lab").link(r1, "supports", c["id"], why="the count is the claim's measurement")
+    assert _state(g, c["id"])["independent_lines"] == 1                 # the same result, not a second line
+
+
+def test_a_claim_whose_bound_result_fell_is_unsupported(env):
+    g, inv, run, r1, r2 = env
+    c = g.author("analyst").add("claim", inv, statement="607 of 821 rows pass the check.", scope="corpus.csv's 821 rows.",
+                                measurements=[{"name": "rows", "result": r1, "key": "rows", "k": 607, "n": 821}],
+                                links=[{"rel": "derived_from", "to": r1}])
+    g.author("lab").withdraw(r1, "the count read the wrong column")
+    st = _state(g, c["id"])
+    assert st["unsupported"] and st["independent_lines"] == 0

hypgraph-0.7.5/tests/test_cited_and_failed_support.py

@@ -0,0 +1,60 @@
+"""The last claims reading 'no live support' after bound results counted: a knowledge claim resting on the sources it
+cites, and claims on results whose author wrote outcome 'failed' for the code under test failing its spec, on runs
+that succeeded (E4: 13 checked claims read UNSUPPORTED — every support has fallen)."""
+import pytest
+
+from hypgraph import Graph, Policy
+from hypgraph import derive as D
+
+
+@pytest.fixture
+def env():
+    g = Graph(policy=Policy(reviewers={"critic"}, instrument="lab"))
+    inv = g.author("lead").investigation("Support", "Find out what a claim rests on.")["id"]
+    return g, inv
+
+
+def _state(g, nid):
+    return D.state(g.snapshot(), nid)
+
+
+def test_a_cited_source_is_a_line_of_support_rated_external(env):
+    g, inv = env
+    r = g.author("researcher")
+    s1 = r.add("source", inv, citation="config.py in the 2.4.0 release", url="file:sources/config.py",
+               passage='"retry_backoff": 30,       # seconds; 60 before 2.3.0')["id"]
+    s2 = r.add("source", inv, citation="The 2.4 configuration guide", url="file:sources/config-guide.md",
+               passage="retry_backoff defaults to 30 seconds")["id"]
+    c = r.add("claim", inv, statement="The default retry_backoff in the current release is 30 seconds.",
+              scope="The 2.4.0 release's config module and its configuration guide.",
+              links=[{"rel": "cites", "to": s1}, {"rel": "cites", "to": s2}])
+    st = _state(g, c["id"])
+    assert st["independent_lines"] == 2 and st["evidence"] == "external" and not st["unsupported"]
+
+
+def test_a_failed_outcome_on_a_succeeded_run_is_a_finding_not_a_fall(env):
+    g, inv = env
+    t = g.author("tester")
+    run = t.add("run", inv, kind="agent", name="spec cases", state="succeeded")["id"]
+    r = t.add("result", inv, kind="computed", outcome="failed",
+              summary="Of the 8 valid-input cases, parse_duration gets exactly 1 wrong: case 8.",
+              values={"valid_wrong": {"k": 1, "n": 8}}, links=[{"rel": "produced", "from": run}])["id"]
+    assert not D.fallen(g.snapshot(), r)
+    c = t.add("claim", inv, statement="parse_duration gets exactly 1 of the 8 valid-input cases wrong.",
+              scope="SPEC.md's 8 valid-input cases on the current diff.",
+              measurements=[{"name": "valid wrong", "result": r, "key": "valid_wrong", "k": 1, "n": 8}],
+              links=[{"rel": "derived_from", "to": r}])
+    st = _state(g, c["id"])
+    assert st["independent_lines"] == 1 and not st["unsupported"] and "UNSUPPORTED" not in st["sentence"]
+
+
+def test_a_failed_outcome_still_falls_when_the_run_failed_or_there_is_none(env):
+    g, inv = env
+    t = g.author("tester")
+    bad = t.add("run", inv, kind="agent", name="spec cases", state="failed")["id"]
+    r1 = t.add("result", inv, kind="computed", outcome="failed", summary="The harness crashed before the cases ran.",
+               values={"n_cases": 12}, links=[{"rel": "produced", "from": bad}])["id"]
+    r2 = t.add("result", inv, kind="computed", outcome="failed", summary="pytest could not import the module.",
+               values={"n_collected": 0})["id"]
+    s = g.snapshot()
+    assert D.fallen(s, r1) and D.fallen(s, r2)

hypgraph-0.7.5/tests/test_relation_words.py

@@ -0,0 +1,38 @@
+"""A relation word the grammar doesn't have is read as the relation it names; a hypothesis derived from a claim is
+motivated by it. The link refusals left after 0.7.3's translation table."""
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+
+
+@pytest.fixture
+def env():
+    g = Graph(policy=Policy(reviewers={"critic"}))
+    lead = g.author("lead")
+    inv = lead.investigation("Words", "Find out which relation words the record reads.")["id"]
+    return g, inv
+
+
+def test_a_run_that_generated_an_artifact_produced_it(env):
+    g, inv = env
+    a = g.author("quant")
+    art = a.add("artifact", inv, sha256="b" * 64, path="grid.csv", kind="data")["id"]
+    run = a.add("run", inv, kind="agent", name="grid", state="succeeded", links=[{"rel": "generated", "to": art}])
+    assert ("produced", art) in {(x["rel"], x["dst"]) for x in g.snapshot().out[run["id"]]}
+    assert any("read as produced" in n for n in run["notes"])
+    out = a.link(run["id"], "used", art, why="the run read the grid", role="data")
+    assert out["rel"] == "uses" and out["notes"]
+
+
+def test_a_hypothesis_derived_from_a_claim_is_motivated_by_it_and_nonsense_is_still_refused(env):
+    g, inv = env
+    a = g.author("stats")
+    c = a.add("claim", inv, statement="steps_k is lower on the supplement arm in the pilot.", scope="pilot.csv, 40 rows.",
+              kind="lead")["id"]
+    h = a.add("hypothesis", inv, statement="The supplement lowers steps_k.",
+              predictions=["steps_k is lower on the supplement arm in the trial."],
+              links=[{"rel": "derived_from", "to": c}])
+    assert ("motivated_by", c) in {(x["rel"], x["dst"]) for x in g.snapshot().out[h["id"]]}
+    with pytest.raises(GraphError) as e:
+        a.link(h["id"], "resembles", c, why="no such relation, and no word for it")
+    assert {p["code"] for p in e.value.problems} == {"LINK_UNKNOWN_RELATION"}