hypgraph 0.8.4__tar.gz → 0.8.5__tar.gz

{hypgraph-0.8.4 → hypgraph-0.8.5}/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## Unreleased
+
+## 0.8.5 — 2026-11-06: fewer false refusals
+
+- A date a source writes as an ordinal is in the source: "the 14th of June 1887" accounts for "14 June 1887". It was refused as an unbound number, and a seat ended up with a claim saying the bridge opened "on a date".
+- A statement with an unfilled slot is refused as STATEMENT_EMPTY: a template's `{date}`, or a variable's name where its value belongs (`accuracy = A_easy_acc`). Inline code is not read for this.
+- **A report that denies significance isn't refused for it.** `REPORT_SIGNIFICANCE_UNBACKED` is a warning, not an
+  error, when the sentence denies the test: emphasis ("*not* significantly"), "no statistically significant difference",
+  "does not support a statistically significant advantage". Before, only the bare "not significant" counted, so an
+  honest negative was refused and small models gave up on the report. A sentence that also asserts significance
+  ("not only significantly", "B is not significantly cheaper, but A is significantly better") stays an error.
+- **A named p-value carries the test.** A result whose values name one (`p`, `p_value`, `pvalue`, `p_exact`, …) backs a
+  significance word, and so does a claim whose statement gives a p-value or that rests on such a result. Before, only a
+  value with a `p` field did, so citing the claim that held the test was refused.
+- **A word and a figure say something.** `STATEMENT_EMPTY` no longer fires on "A's accuracy is 0.814."; placeholders
+  still do, with a number beside them or not.
+
 ## 0.8.4 — 2026-11-04: sources in the sidebar; a focus on one node's part of the graph
 
 - **A Sources view in the Explorer's sidebar.** Everything an investigation cites, in one place: outside literature

{hypgraph-0.8.4 → hypgraph-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.8.4
+Version: 0.8.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.8.4 → hypgraph-0.8.5}/docs/PLAN.md

@@ -109,7 +109,7 @@ claim's derived standing.
 Multi-writer sync between graphs (bundles cover sharing), authentication (the host's job; the HTTP server binds to
 loopback and is read-only unless started with `--writable`), and a hosted service.
 
-## Status at 0.8.4 (2026-11-04)
+## Status at 0.8.5 (2026-11-06)
 
 All seven phases are done: the library, bundles, the server and UI, the MCP server, the website, Pegasus running on
 the package, and releases to PyPI from tags with trusted publishing. What came after the plan, by release, is in

{hypgraph-0.8.4 → hypgraph-0.8.5}/docs/RELEASE-READINESS.md

@@ -261,6 +261,12 @@ was taken from a changelog without being checked against the code.*
 > with two or more of them when the exporting and verifying processes hashed strings differently. The list now follows
 > the order the hypotheses were added. #109 is merged with green CI. Released as 0.8.3.
 
+> **After 0.8.4 (2026-11-06).** Checks only, no change to the bundle format: false refusals found running HypSwarm on a
+> small local model. A report that denies significance is warned, not refused; a named p-value carries the test; a word
+> and a figure are a statement, and an unfilled slot isn't; an ordinal in a source accounts for the number. Tests:
+> `tests/test_report_significance_denied.py`, `tests/test_statement_slots.py`, `tests/test_versions_not_figures.py`.
+> #113 is merged with green CI. Released as 0.8.5.
+
 > **After 0.8.3 (2026-11-04).** Explorer only, no change to the engine, the checks or the bundle format: a Sources view
 > (what an investigation cites, with what the record did and did not check about each) and a focus on one node's part
 > of the graph, carried in the link. The focus is computed in the browser from the record's own edges;

{hypgraph-0.8.4 → hypgraph-0.8.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.8.4"
+__version__ = "0.8.5"
 
 from .bundle import anchored, verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.8.4 → hypgraph-0.8.5}/src/hypgraph/checks.py

@@ -1598,6 +1598,9 @@ def _exclusion(s: Snap, stmt: str, kind: str, support: list[str], bound: list) -
                     "effect", words=words)]
 
 
+_ORDINAL = re.compile(r"\b(\d+)(?:st|nd|rd|th)\b", re.I)
+# a value not filled in: a template's {date}, or a variable's name where its value belongs ("accuracy = A_easy_acc")
+_SLOT = re.compile(r"\{\s*[A-Za-z_][\w.]*\s*\}|=\s*[A-Za-z]+_[A-Za-z0-9_]*\b(?!\s*\()")
 _PLACEHOLDER = re.compile(r"^\W*(?:(?:placeholder|tbd|todo|tba|n/?a|none|wip|xxx|test|claim|statement|pending|"
                           r"to be (?:determined|confirmed|added)|lorem ipsum)\W*)+$", re.I)
 
@@ -1776,13 +1779,20 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
     if invb.get("strict_claims") is False:
         return []
     problems: list[Problem] = []
-    if _PLACEHOLDER.match(stmt) or len(re.findall(r"[^\W\d_]{3,}", stmt)) < 2:
-        # a claim written to clear a gate (studies/challenges E2: "Placeholder.", contested and left in the record)
+    words = len(re.findall(r"[^\W\d_]{3,}", stmt))
+    if _PLACEHOLDER.match(_NUM.sub("", stmt)) or words < (1 if _NUM.search(stmt) else 2):
+        # a claim written to clear a gate (studies/challenges E2: "Placeholder.", contested and left in the record);
+        # a word and a figure do say something: "A's accuracy is 0.814."
         problems.append(Problem("STATEMENT_EMPTY", "the statement says nothing: write the finding itself — what was "
                                 "measured, on what, and what it came to"))
     if kind in ("finding", "exclusion") and len(scope.strip()) < 10:
         problems.append(Problem("SCOPE_MISSING", "scope: say under which conditions this holds (the data, method, "
                                 "sample) — at least a sentence"))
+    slot = _SLOT.search(re.sub(r"`[^`]*`", " ", stmt))
+    if slot:
+        # refused the date, a seat wrote "opened on {date}", and a later version "on a date" was checked as the answer
+        problems.append(Problem("STATEMENT_EMPTY", f"the statement has an unfilled slot ({slot.group(0).strip()}): "
+                                "write the value itself", words=[slot.group(0).strip()]))
     if kind == "convention" and L.HEDGE.search(stmt):
         problems.append(Problem("CONVENTION_HEDGED", "a convention states agreed notation; a hedged interpretation "
                                 "(could / suggests / consistent with) is a finding or a lead"))
@@ -1799,7 +1809,8 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
         [float(c) for c in (invb.get("constants") or []) if isinstance(c, (int, float))]
     for src in support:                              # a cited source's own text accounts for the numbers in it
         sb = s.nodes[src]["body"] if s.nodes[src]["type"] == "source" else {}
-        allowed += [v for v, *_ in numbers(" ".join(str(sb.get(k) or "") for k in ("passage", "citation", "title")))]
+        said = " ".join(str(sb.get(k) or "") for k in ("passage", "citation", "title"))
+        allowed += [v for v, *_ in numbers(_ORDINAL.sub(r"\1", said))]   # "the 14th of June" accounts for "14 June"
     if _CONVENTIONS.search(clean):                   # "95% interval", "α 0.05", "80% power" are conventions
         allowed += [95.0, 99.0, 90.0, 80.0, 0.05, 0.01]
     loose = [p for p in numbers(clean) if not _matches(p, allowed) and not _matches_stat(p, stat)]

{hypgraph-0.8.4 → hypgraph-0.8.5}/src/hypgraph/report_check.py

@@ -92,6 +92,28 @@ def _asserted(pattern: re.Pattern, text: str) -> list[str]:
     return [m.group(0).lower() for m in pattern.finditer(text) if not _NEGATOR.search(text[:m.start()])]
 
 
+_P_KEY = re.compile(r"p(?:[_-]?val(?:ue)?|_[a-z0-9_]+)?", re.I)
+
+
+def _carries_test(s: D.Snap, nid: str) -> bool:
+    """Does this node hold a test: a two-sample count the record worked out, a value with a p, a value named as one
+    (p_value, p_exact, pvalue), or, for a claim, its own statement's p-value or any such result it rests on?"""
+    def holds(n: str) -> bool:
+        vals = s.nodes[n]["body"].get("values") or {}
+        return bool(D.state(s, n).get("test")) or any(
+            _P_KEY.fullmatch(str(k)) or (isinstance(v, dict) and "p" in v) for k, v in vals.items())
+    if holds(nid):
+        return True
+    n = s.nodes[nid]
+    if n["type"] != "claim":
+        return False
+    if _P_VALUE.search(n["body"].get("statement") or ""):
+        return True
+    bound = [m.get("result") for m in n["body"].get("measurements") or [] if isinstance(m, dict)]
+    rests = [e["dst"] for e in s.out.get(nid, []) if e["rel"] == "derived_from"]
+    return any(holds(r) for r in [*bound, *rests] if r in s.nodes)
+
+
 def _blank(m: re.Match) -> str:
     return re.sub(r"[^\n]", " ", m.group(0))
 
@@ -286,9 +308,10 @@ def check(g: "Graph", text: str, inv: str = "") -> dict:
                     f"'{causal[0]}' is causal and no claim is cited — cite the claim backed by an experiment, or say "
                     "'is associated with'.")
             sig = L.found(L.SIGNIFICANCE, own)
-            if sig and not _P_VALUE.search(sent) and not any(D.state(s, c).get("test") or any(isinstance(v, dict) and "p" in v for v in
-                               (s.nodes[c]["body"].get("values") or {}).values()) for c in cited):
-                negated = re.search(r"\bnot\s+(?:statistically\s+)?(?:significant|unusual)|\bnon-?significant", sent, re.I)
+            if sig and not _P_VALUE.search(sent) and not any(_carries_test(s, c) for c in cited):
+                # the sentence denies the test rather than claims it: emphasis ("*not* significantly") is no assertion
+                plain = re.sub(r"\bnot\s+(?:only|just|merely)\b", "", re.sub(r"[*_]", "", own), flags=re.I)
+                negated = bool(L.denied(L.SIGNIFICANCE, plain)) and not L.asserted(L.SIGNIFICANCE, plain)
                 add(ln, "warning" if negated else "error", "REPORT_SIGNIFICANCE_UNBACKED", sent,
                     f"'{sig[0]}' — cite the claim or result that carries the test.")
     _check_answers(s, text or "", invs, by_code, add, counted)

hypgraph-0.8.5/tests/test_report_significance_denied.py

@@ -0,0 +1,62 @@
+"""0.8.5: a report that says a difference was NOT significant isn't claiming a test passed, and a claim resting on a
+named p-value carries its test. From gpt-oss runs on a small box: leads wrote "*not* significantly" and were refused
+until they gave up, so two of six runs ended with no interpretation."""
+import pytest
+
+from hypgraph import Graph, Policy
+
+
+def _record(values):
+    g = Graph(policy=Policy(reviewers={"critic"}))
+    inv = g.create(author="h", type="investigation", fields={"title": "Does A beat B.", "objective": "Compare A and B on the same items."})["id"]
+    q = g.create(author="h", type="question", inv=inv, code="Q2",
+                 fields={"text": "Is A significantly more accurate than B (two-sided, 0.05)?"})["id"]
+    r = g.create(author="stats", type="run", inv=inv, fields={"kind": "agent", "name": "mcnemar", "state": "succeeded"})
+    rs = g.create(author="stats", type="result", inv=inv, fields={"summary": "McNemar test on the same 1,000 items.", "values": values},
+                  links=[{"rel": "produced", "from": r["id"]}])
+    c = g.create(author="stats", type="claim", inv=inv,
+                 fields={"statement": "The McNemar test on the 1,000 shared items gave the value in the result.",
+                         "scope": "The 1,000 shared items."},
+                 links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs["id"]}])
+    return g, inv, c["code"], rs["code"]
+
+
+def _sig(g, text, inv):
+    return [f["level"] for f in g.check_text(text, inv)["findings"] if f["code"] == "REPORT_SIGNIFICANCE_UNBACKED"]
+
+
+@pytest.mark.parametrize("sentence", [
+    "Model A is *not* significantly more accurate than model B.",
+    "Model A is **not** significantly more accurate than model B.",
+    "There is no statistically significant difference between A and B.",
+    "The evidence does not support a statistically significant advantage for A.",
+    "The test did not reach statistical significance, so A is not significantly better.",
+])
+def test_a_denial_is_a_warning_not_a_refusal(sentence):
+    g, inv, _, _ = _record({"chi2": {"value": 3.0}})
+    assert _sig(g, sentence, inv) in (["warning"], [])
+    assert g.check_text(sentence, inv)["errors"] == 0
+
+
+@pytest.mark.parametrize("sentence", [
+    "A is significantly more accurate than B.",
+    "A is not only significantly more accurate than B, it is cheaper.",
+    "A is not worse, and it is significantly more accurate than B.",
+    "B is not significantly cheaper, but A is significantly more accurate.",
+])
+def test_an_assertion_is_still_refused(sentence):
+    g, inv, _, _ = _record({"chi2": {"value": 3.0}})
+    assert _sig(g, sentence, inv) == ["error"]
+
+
+@pytest.mark.parametrize("key", ["p", "p_value", "pvalue", "p-value", "p_exact", "p_two"])
+def test_a_named_p_value_carries_the_test(key):
+    g, inv, cl, rs = _record({key: {"value": 0.03}})
+    assert _sig(g, f"A is significantly more accurate than B ({rs}).", inv) == []       # the result itself
+    assert _sig(g, f"A is significantly more accurate than B ({cl}).", inv) == []       # the claim that rests on it
+
+
+def test_a_claim_without_a_test_does_not_carry_one():
+    g, inv, cl, rs = _record({"pct_a": {"value": 90.0}, "pairs": {"value": 322}, "chi2": {"value": 3.0}})
+    assert _sig(g, f"A is significantly more accurate than B ({cl}).", inv) == ["error"]
+    assert _sig(g, f"A is significantly more accurate than B ({rs}).", inv) == ["error"]

hypgraph-0.8.5/tests/test_statement_slots.py

@@ -0,0 +1,60 @@
+"""A number a source writes as an ordinal is in the source, and a statement with a slot in it says nothing. Found on a
+BC-250 run of the knowledge challenge: the passage said "the 14th of June 1887", "14 June 1887" was refused as unbound
+12 times, the seat wrote "opened on {date}", then "opened on a date", and that was checked as the answer."""
+from __future__ import annotations
+
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+
+
+def _record():
+    g = Graph(policy=Policy(reviewers={"critic"}))
+    inv = g.create(author="a", type="investigation", fields={
+        "title": "The footbridge", "objective": "When did the footbridge open?", "profile": "knowledge@2"})["id"]
+    src = g.create(author="a", type="source", inv=inv, fields={
+        "url": "file:archive/minutes.md", "kind": "primary", "retrieved": "2026-11-05",
+        "citation": "Council minutes, 2 May",
+        "passage": "Resolved that the bridge be opened to the public on Tuesday the 14th of June 1887."})["id"]
+    return g, inv, src
+
+
+def _claim(g, inv, src, statement):
+    return g.create(author="a", type="claim", inv=inv, fields={
+        "statement": statement, "scope": "The council minutes of the town, read in full."},
+        links=[{"rel": "cites", "to": src}, {"rel": "supports", "from": src, "why": "the minutes name the day it opened"}])
+
+
+@pytest.mark.parametrize("statement", ["The footbridge opened to the public on 14 June 1887.",
+                                       "The footbridge opened to the public on the 14th of June 1887."])
+def test_a_date_written_as_an_ordinal_is_in_the_source(statement):
+    g, inv, src = _record()
+    assert _claim(g, inv, src, statement)["id"]
+
+
+def test_a_number_the_source_doesnt_have_stays_unbound():
+    g, inv, src = _record()
+    with pytest.raises(GraphError, match="UNBOUND_NUMBER"):
+        _claim(g, inv, src, "The footbridge opened to the public on 15 June 1887.")
+
+
+@pytest.mark.parametrize("statement", [
+    "The footbridge opened to the public on {date}.",
+    "The footbridge opened to the public on { date }.",
+    "Model A easy accuracy = A_easy_acc on the items.",
+    "The strategy with fast window {fast_window} returned the most.",
+])
+def test_a_statement_with_a_slot_is_refused(statement):
+    g, inv, src = _record()
+    with pytest.raises(GraphError, match="STATEMENT_EMPTY"):
+        _claim(g, inv, src, statement)
+
+
+@pytest.mark.parametrize("statement", [
+    "The minutes set the option `retry = max_tries` for the footbridge.",
+    "The function returned `{date}` for the footbridge.",
+    "The footbridge opened in the summer, as the minutes say.",
+])
+def test_code_and_plain_sentences_are_not_slots(statement):
+    g, inv, src = _record()
+    assert _claim(g, inv, src, statement)["id"]

{hypgraph-0.8.4 → hypgraph-0.8.5}/tests/test_versions_not_figures.py

@@ -76,3 +76,11 @@ def test_a_statement_that_says_nothing_is_refused(tmp_path):
     for i, stmt in enumerate(("Placeholder.", "Placeholder claim.", "TBD — pending.", "To be determined.", "1234567890 ...")):
         assert "STATEMENT_EMPTY" in _claim_error(tmp_path / f"{i}.hypgraph", stmt), stmt
     assert _claim_error(tmp_path / "real.hypgraph", "parse_duration truncates rather than rounds.") == ""
+
+
+def test_a_word_and_a_figure_say_something(tmp_path):
+    """From gpt-oss runs: "A's accuracy is 0.814." has one word of three letters, and was refused as saying nothing."""
+    for i, stmt in enumerate(("A's accuracy is 0.814.", "Accuracy: 81.4 %.")):
+        assert "STATEMENT_EMPTY" not in _claim_error(tmp_path / f"{i}.hypgraph", stmt), stmt
+    for i, stmt in enumerate(("TBD 12.", "Placeholder 3.", "Placeholder 3 — pending.", "See RS1.", "12.")):
+        assert _claim_error(tmp_path / f"e{i}.hypgraph", stmt), stmt            # some are too short to reach this check