hypgraph 0.8.1__tar.gz → 0.8.2__tar.gz

{hypgraph-0.8.1 → hypgraph-0.8.2}/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.8.2 — 2026-11-01: an extreme that quotes its own counterexample; a disputed answer
+
+- **A quoted counterexample no longer excuses an extreme.** A stated count used to exempt an extreme whenever its
+  clause said "k of n ... than", meant for a count about a figure of the statement's own ("the shortest is 21 km; 1 of
+  77 are shorter than 26 km"). It also exempted the count at the extreme's own figure, so "the shortest route is 30 km,
+  since 1 of 77 are shorter than 30 km" was accepted. The count is now an exception to the extreme whenever its figure,
+  on the result or in the sentence, is the extreme's own.
+- **Two readings that exemption had hidden.** "The highest ... is therefore not 125" is a denial (an adverb between
+  the copula and "not"), and a bound in the extreme's own direction ("the shortest is at most 30 km", "91 or more") is
+  not a claim that the figure is the extreme. A bound the other way ("the shortest is at least 30 km") still claims it.
+- Replayed on 1,900 recorded claim writes: 5 change, all now refused. Four are an extreme stated beside the count
+  that shows it false. One is a retraction worded as the claim ("the highest is 80, but this is not correct: 3 of
+  1,024 are worth more"). Who the record names as still saying something false is unchanged or better on every set.
+- **`hypgraph demo dispute`: a disputed answer.** A teaching record in which two parties answer one question from the
+  same road register. Ada makes an honest mistake, the record refuses it (`COUNT_CONTRADICTS`) and she corrects it.
+  Mallory cites the register's units note for a claim it contradicts, is refused twice (`SOURCE_CONTRADICTS`) and files
+  it without the note. An independent reviewer checks one claim and fails the other, so the Evidence view shows one
+  answer checked and one contested, and `Graph.conduct()` names who kept saying it. It is also on the website
+  (`examples/dispute/`, in every site language) and in the README. `hypgraph demo` with no name still builds Broad
+  Street.
+
 ## 0.8.1 — 2026-11-01: exact figures, units within their kind
 
 An independent audit of 0.8.0 found two defects in the typed checks, both confirmed on the published wheel.

{hypgraph-0.8.1 → hypgraph-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.8.1
+Version: 0.8.2
 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/
@@ -136,6 +136,34 @@ CL1 — withdrawn claim · …
   ⚠ 2 nodes rest on CL1: 1 decision (D1); 1 claim (CL2) — now AT RISK
 ```
 
+## Calling out a bad answer
+
+Two agents answer one question from the same road register. One makes an honest mistake and the other lies. The
+record tells them apart, and nobody has to label anyone:
+
+<p align="center"><a href="https://hypgraph.com/examples/dispute/"><picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://hypgraph.com/assets/readme/dispute-dark.png">
+  <img src="https://hypgraph.com/assets/readme/dispute-light.png" width="880" alt="The Evidence view of a disputed answer: Ada's claim that the shortest route is 29 km is checked, Mallory's claim that the register is in miles is contested, above the two route counts the instrument filed and the seven register items they rest on">
+</picture></a></p>
+<p align="center"><sub>Standing derived from the record: one answer checked, the other contested. <code>hypgraph demo dispute</code> builds it; <a href="https://hypgraph.com/examples/dispute/">open it live</a>.</sub></p>
+
+- **Ada** says the shortest route is 30 km. The instrument counted 1 of the 4 routes as shorter, so the record refuses
+  it (`COUNT_CONTRADICTS`). She corrects it to 29 km, which the count backs.
+- **Mallory** says the register is in miles, and cites the register's own units note as support. The note says
+  kilometres, so the record refuses it (`SOURCE_CONTRADICTS`). She says it again and is refused again.
+
+The record can't catch every lie by itself: once Mallory stops citing the note, her claim goes in. But it keeps what
+she was shown. The reviewer fails her claim against the note, and the conduct log (`hypgraph refusals`,
+`Graph.conduct()`) says who corrected what they were shown and who kept saying it:
+
+```text
+$ hypgraph demo dispute
+…
+What the record says of each author:
+  ada        the record's own count contradicted a claim of this author's 1 time; the author did not say it again, and corrected it 1 time
+  mallory    1 claim of this author's went against a source it cited as support; the author said it again 2 times after being shown, and never corrected it; its last word still says it
+```
+
 ## Derived, never asserted
 
 Nothing in the record is ever *set* as known. How well each claim is known is **derived on every read**:

{hypgraph-0.8.1 → hypgraph-0.8.2}/README.md

@@ -104,6 +104,34 @@ CL1 — withdrawn claim · …
   ⚠ 2 nodes rest on CL1: 1 decision (D1); 1 claim (CL2) — now AT RISK
 ```
 
+## Calling out a bad answer
+
+Two agents answer one question from the same road register. One makes an honest mistake and the other lies. The
+record tells them apart, and nobody has to label anyone:
+
+<p align="center"><a href="https://hypgraph.com/examples/dispute/"><picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://hypgraph.com/assets/readme/dispute-dark.png">
+  <img src="https://hypgraph.com/assets/readme/dispute-light.png" width="880" alt="The Evidence view of a disputed answer: Ada's claim that the shortest route is 29 km is checked, Mallory's claim that the register is in miles is contested, above the two route counts the instrument filed and the seven register items they rest on">
+</picture></a></p>
+<p align="center"><sub>Standing derived from the record: one answer checked, the other contested. <code>hypgraph demo dispute</code> builds it; <a href="https://hypgraph.com/examples/dispute/">open it live</a>.</sub></p>
+
+- **Ada** says the shortest route is 30 km. The instrument counted 1 of the 4 routes as shorter, so the record refuses
+  it (`COUNT_CONTRADICTS`). She corrects it to 29 km, which the count backs.
+- **Mallory** says the register is in miles, and cites the register's own units note as support. The note says
+  kilometres, so the record refuses it (`SOURCE_CONTRADICTS`). She says it again and is refused again.
+
+The record can't catch every lie by itself: once Mallory stops citing the note, her claim goes in. But it keeps what
+she was shown. The reviewer fails her claim against the note, and the conduct log (`hypgraph refusals`,
+`Graph.conduct()`) says who corrected what they were shown and who kept saying it:
+
+```text
+$ hypgraph demo dispute
+…
+What the record says of each author:
+  ada        the record's own count contradicted a claim of this author's 1 time; the author did not say it again, and corrected it 1 time
+  mallory    1 claim of this author's went against a source it cited as support; the author said it again 2 times after being shown, and never corrected it; its last word still says it
+```
+
 ## Derived, never asserted
 
 Nothing in the record is ever *set* as known. How well each claim is known is **derived on every read**:

{hypgraph-0.8.1 → hypgraph-0.8.2}/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.1 (2026-11-01)
+## Status at 0.8.2 (2026-11-01)
 
 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.1 → hypgraph-0.8.2}/docs/RELEASE-READINESS.md

@@ -249,6 +249,13 @@ was taken from a changelog without being checked against the code.*
 > the statement. Untyped mode keeps its documented limits. #104 is merged with green CI (17 of 17 checks). Released as
 > 0.8.1.
 
+> **After 0.8.1 (2026-11-01).** The frozen word checks were changed once, for a soundness gap rather than a new
+> wording: a stated count exempted an extreme even when the count was at the extreme's own figure, so an extreme that
+> quoted its own counterexample was accepted. The exemption now holds only for a count about another figure; an adverb
+> before "not" and a bound in the extreme's own direction are read as what they are. Replaying the 1,900 recorded
+> claim writes changes 5, all now refused (4 lies, 1 retraction worded as the claim). #106 is merged with green CI.
+> Released as 0.8.2, with the `dispute` demo (#107).
+
 ## Recommendation: CONDITIONAL GO
 
 HypGraph is ready for a public developer preview once #59, #60 and #61 are merged with green CI and released as one

{hypgraph-0.8.1 → hypgraph-0.8.2}/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.1"
+__version__ = "0.8.2"
 
 from .bundle import anchored, verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.8.1 → hypgraph-0.8.2}/src/hypgraph/checks.py

@@ -955,22 +955,34 @@ def claimed_extremes(stmt: str) -> list[str]:
                               if not _enumerated(stmt, w) and not _names_stated_count(stmt, w)]
 
 
+# an adverb between the copula and its negation: "the highest ... is therefore not 125"
+_ADVERB = r"(?:(?:therefore|thus|hence|then|so|also|still|\w+ly)\s+)?"
 # the extreme's own predicate denied after it, in its clause: "the highest total value ... is not 130"
-_DENIED_EXTREME = re.compile(r"\b(?:is|are|was|were)\s+(?:not|no longer|never)\b|\b(?:isn't|aren't|wasn't|weren't)\b|"
+_DENIED_EXTREME = re.compile(r"\b(?:is|are|was|were)\s+" + _ADVERB + r"(?:not|no longer|never)\b|"
+                             r"\b(?:isn't|aren't|wasn't|weren't)\b|"
                              # or said to lie beyond a figure: "the true maximum is higher than 98"
                              r"\b(?:is|are|was|were|lies)\s+(?:\w+\s+)?(?:higher|lower|greater|larger|smaller|more|less|"
                              r"above|below|over|under|shorter|longer|beyond)\b", re.I)
 # or denied before it: "120 is not the highest total value", "isn't the shortest"
-_DENIED_BEFORE = re.compile(r"(?:\b(?:is|are|was|were)\s+(?:not|no longer|never)|\b(?:isn't|aren't|wasn't|weren't))"
+_DENIED_BEFORE = re.compile(r"(?:\b(?:is|are|was|were)\s+" + _ADVERB + r"(?:not|no longer|never)|"
+                            r"\b(?:isn't|aren't|wasn't|weren't))"
                             r"\s+(?:the\s+|a\s+|an\s+)?(?:true\s+|real\s+|actual\s+)?$", re.I)
 _COPULA = re.compile(r"\b(?:is|are|was|were|isn't|aren't|wasn't|weren't|lies)\b", re.I)
 
 
-def _denied(after: str) -> bool:
+def _denied(after: str, w: str = "") -> bool:
     """Does the extreme's own predicate — the first copula after it — deny it or put it beyond a figure? Only that
-    one: "the highest value is 98 ..., so the true maximum is higher" still claims 98."""
+    one: "the highest value is 98 ..., so the true maximum is higher" still claims 98. A bound in the extreme's own
+    direction is beyond its figure too: "the highest value is at least 91" (or "91 or more") says the true maximum is
+    91 or above, which what lies beyond 91 doesn't contradict; "the highest is at most 91" still claims a figure."""
     cop = _COPULA.search(after)
-    return bool(cop and _DENIED_EXTREME.match(after, cop.start()))
+    if not cop:
+        return False
+    if _DENIED_EXTREME.match(after, cop.start()):
+        return True
+    own = {s for _a, s, _strict in _comparisons_in(w)}
+    pred = after[cop.end():].split(",")[0]
+    return bool(own) and any(not strict and s in own for _a, s, strict in _comparisons_in(pred))
 
 
 # a count named for what lies beyond a figure ("fitting selections worth more", "shorter routes connecting") is about
@@ -988,7 +1000,7 @@ def _extremes(stmt: str) -> list[str]:
         for m in re.finditer(r"\b" + re.escape(w) + r"\b", stmt, re.I):
             end = next((x.start() for x in _CLAUSE.finditer(stmt, m.end())), len(stmt))
             start = max((x.end() for x in _CLAUSE.finditer(stmt, 0, m.start())), default=0)
-            if (not _denied(stmt[m.end():end]) and not _DENIED_BEFORE.search(stmt[start:m.start()])
+            if (not _denied(stmt[m.end():end], w) and not _DENIED_BEFORE.search(stmt[start:m.start()])
                     and re.search(r"\d", stmt[start:end])):
                 out.append(w)
                 break
@@ -1011,11 +1023,23 @@ def _count_contradicts(stmt: str, w: str, words: list, m: dict, k: int, n: int)
                    words=words + [f"={_fmt(v)}" for v in _subject_numbers(stmt, k, n)])
 
 
-def _qualified(stmt: str, k: int, n: int) -> bool:
+_THAN_FIGURE = re.compile(r"\bthan\s+\$?(-?\d[\d,]*(?:\.\d+)?)", re.I)
+
+
+def _qualified(stmt: str, k: int, n: int, figs: frozenset = frozenset(), rv: dict | None = None) -> bool:
     """Does the statement give this count about a figure of its own ("1 of 61 routes are shorter than 26 km")?
-    Then it's a count of something beyond that figure, not of exceptions to the extreme it claims."""
+    Then it's a count of something beyond that figure, not of exceptions to the extreme it claims. Not when the
+    figure is the extreme's own: "the shortest route is 30 km, since 1 of 77 are shorter than 30 km" states the very
+    count that shows it false, and quoting the counterexample doesn't make an extreme true."""
+    if figs and rv is not None and stated_figure(rv) in figs:
+        return False
     forms = {f"{k} of {n}", f"{k:,} of {n:,}"}
-    return any(any(f in c for f in forms) and re.search(r"\bthan\b", c) for c in _CLAUSE.split(stmt))
+    for c in _CLAUSE.split(stmt):
+        if any(f in c for f in forms) and re.search(r"\bthan\b", c):
+            said = {float(x.replace(",", "")) for x in _THAN_FIGURE.findall(c)}
+            if not (said & set(figs)):
+                return True
+    return False
 
 
 def _superlative_contradicted(stmt: str, bound: list) -> list[Problem]:
@@ -1032,7 +1056,7 @@ def _superlative_contradicted(stmt: str, bound: list) -> list[Problem]:
                and (L.content_words(f"{m.get('name', '')} {m.get('key', '')}") & about
                     or _BEYOND.search(f"{m.get('name', '')} {m.get('key', '')}".replace("_", " "))
                     or stated_figure(rv) in figs)
-               and not (role == "refute" and _qualified(stmt, *a))]
+               and not (role == "refute" and _qualified(stmt, *a, figs, rv))]
         # a count beyond the extreme's own figure that finds some refutes it, whatever else is bound beside it
         pinned = [(m, a) for m, rv, a, role in rel if role == "refute" and _pinned(m, rv, set(figs))]
         if pinned:
@@ -1061,7 +1085,7 @@ def _extreme_claims(stmt: str) -> list[tuple[str, frozenset]]:
             end = next((x.start() for x in _CLAUSE.finditer(stmt, m.end())), len(stmt))
             start = max((x.end() for x in _CLAUSE.finditer(stmt, 0, m.start())), default=0)
             after = stmt[m.end():end]
-            if _denied(after) or _DENIED_BEFORE.search(stmt[start:m.start()]):
+            if _denied(after, w) or _DENIED_BEFORE.search(stmt[start:m.start()]):
                 continue
             cop = _COPULA.search(after)
             fig = _FIGURE.match(after, cop.end()) if cop else None

{hypgraph-0.8.1 → hypgraph-0.8.2}/src/hypgraph/cli.py

@@ -2,6 +2,7 @@
 hypgraph — the command line.
 
     hypgraph demo                       build the Broad Street (1854) teaching investigation into ./research.hypgraph
+    hypgraph demo dispute               an honest mistake and a lie: the record checks one and contests the other
     hypgraph serve                      open the HypGraph UI on http://127.0.0.1:8765
     hypgraph init "Plant growth" --objective "…" --reviewers ada,lin
     hypgraph add hypothesis statement="Blue light grows cress faster." predictions='["taller after 7 days"]'
@@ -351,19 +352,27 @@ def cmd_import(args) -> int:
 
 
 def cmd_demo(args) -> int:
-    from .demos import broad_street
+    import importlib
+
+    from .demos import DEMOS
+    demo = importlib.import_module(DEMOS[args.name])
     if Path(args.db).exists():
-        raise GraphError(f"{args.db} exists — choose another file: hypgraph demo --db broad-street.hypgraph")
-    g, inv, story = broad_street.build(path=args.db)
+        raise GraphError(f"{args.db} exists — choose another file: hypgraph demo {args.name} --db {args.name}.hypgraph")
+    g, inv, story = demo.build(path=args.db)
+    conduct = g.conduct(inv) if args.name == "dispute" else {}
     if args.json:
-        _out(args, {"db": g.path, "inv": inv, "story": story})
+        _out(args, {"db": g.path, "inv": inv, "story": story, **({"conduct": conduct} if conduct else {})})
         return 0
     for s in story:
         print(f"{s['at']}  {s['actor']:<10} {s['text']}")
         if "refused" in s:
             print("            ✗ the record refused it:\n              " +
                   s["refused"].replace("\n", "\n              "))
-    print(f"\nBuilt {broad_street.TITLE!r} into {g.path}.\nExplore it:  hypgraph --db {args.db} serve"
+    if conduct:
+        print("\nWhat the record says of each author:")
+        for who, row in conduct.items():
+            print(f"  {who:<10} {row['sentence']}")
+    print(f"\nBuilt {demo.TITLE!r} into {g.path}.\nExplore it:  hypgraph --db {args.db} serve"
           f"   ·   hypgraph --db {args.db} report")
     return 0
 
@@ -553,7 +562,9 @@ def build_parser() -> argparse.ArgumentParser:
                         "outside the hash chain")
     s = cmd("import", cmd_import, "rebuild a graph file from a complete bundle")
     s.add_argument("bundle")
-    cmd("demo", cmd_demo, "build the Broad Street (1854) teaching investigation")
+    s = cmd("demo", cmd_demo, "build a teaching investigation: Broad Street (1854), or a disputed answer")
+    s.add_argument("name", nargs="?", default="broad-street", choices=["broad-street", "dispute"],
+                   help="broad-street (default), or dispute: an honest mistake and a lie, told apart by the record")
     cmd("schema", cmd_schema, "the node types and relations")
     s = cmd("refusals", cmd_refusals, "the overclaims the record caught: per author, per rule, fixed or open")
     s.add_argument("--inv", default="")

{hypgraph-0.8.1 → hypgraph-0.8.2}/src/hypgraph/demos/__init__.py

@@ -1,3 +1,3 @@
 """Teaching investigations that ship with HypGraph. ``hypgraph demo`` builds one into a file you can explore."""
 
-DEMOS = {"broad-street": "hypgraph.demos.broad_street"}
+DEMOS = {"broad-street": "hypgraph.demos.broad_street", "dispute": "hypgraph.demos.dispute"}

hypgraph-0.8.2/src/hypgraph/demos/dispute.py

@@ -0,0 +1,168 @@
+"""
+A disputed answer — two parties, one honest mistake, one lie, and the record that tells them apart.
+
+A small road register answers one question: how long is the shortest route from Kelso to Holme? Two parties answer
+it, and an independent reviewer reads what the record holds. The record does the counting: every route is
+enumerated by the instrument (author ``lab``), so a claim about "the shortest" meets the count of routes shorter
+than its figure.
+
+- **Ada** makes an honest mistake: she adds up the wrong route and says 30 km. The instrument finds 1 of the 4 routes
+  shorter, and the record refuses her claim (``COUNT_CONTRADICTS``). She corrects it to 29 km, which the count backs.
+- **Mallory** argues in bad faith: the register's distances are in miles, not kilometres, so no answer stands. She
+  cites the register's own units note as support; it says kilometres, and the record refuses her
+  (``SOURCE_CONTRADICTS``). She says it again, and is refused again. Then she drops the note and files the same lie
+  against Ada's answer, which the record can't check without the note, so it goes in.
+- **Ruth**, the reviewer, checks both against the register: Ada's claim is checked, Mallory's fails.
+
+Nobody labels anyone. What the Evidence view shows — Ada's claim *checked*, Mallory's *contested* — and what the
+conduct log says — Ada corrected what she was shown, Mallory kept saying it — are derived from the record on read.
+
+    from hypgraph.demos import dispute
+    g, inv, story = dispute.build()
+"""
+
+from __future__ import annotations
+
+from itertools import permutations
+
+from ..graph import Graph, GraphError
+from ..policy import Policy
+from .broad_street import DemoClock
+
+TITLE = "A disputed answer: the shortest route from Kelso to Holme"
+QUESTION = "How long is the shortest route by road from Kelso to Holme?"
+
+# The register: each road, both ways, in kilometres (the note says so).
+ROADS = [("Kelso", "Elstow", 22), ("Elstow", "Holme", 7), ("Kelso", "Lydney", 14), ("Lydney", "Elstow", 9),
+         ("Lydney", "Corfe", 12), ("Corfe", "Holme", 19)]
+NOTE = "Register note: every road can be driven in either direction, and every distance in the register is in kilometres."
+
+
+def routes(a: str = "Kelso", b: str = "Holme") -> list[tuple[list[str], int]]:
+    """Every route from ``a`` to ``b`` that visits no town twice, with its length: what the instrument counts over."""
+    length = {frozenset((x, y)): d for x, y, d in ROADS}
+    towns = sorted({t for x, y, _ in ROADS for t in (x, y)} - {a, b})
+    out = []
+    for k in range(len(towns) + 1):
+        for mid in permutations(towns, k):
+            path = [a, *mid, b]
+            legs = [frozenset(p) for p in zip(path, path[1:])]
+            if all(leg in length for leg in legs):
+                out.append((path, sum(length[leg] for leg in legs)))
+    return sorted(out, key=lambda r: (r[1], r[0]))
+
+
+def build(g: Graph | None = None, path: str | None = None) -> tuple[Graph, str, list[dict]]:
+    """Build the dispute. Returns (graph, investigation id, story): every step in order, with the refusals."""
+    clock = DemoClock("2026-11-02T09:00:00+00:00")
+    if g is None:
+        g = Graph(path, policy=Policy(reviewers={"ruth"}), clock=clock)
+    else:
+        g.clock = clock
+    story: list[dict] = []
+    all_routes = routes()
+    n = len(all_routes)
+
+    def say(who: str, what: str, node: dict | None = None) -> None:
+        story.append({"at": clock(), "actor": who, "text": what,
+                      **({"node": node["id"], "code": node["code"]} if node else {})})
+
+    def refused(who: str, what: str, attempt) -> None:
+        try:
+            attempt()
+        except GraphError as e:
+            story.append({"at": clock(), "actor": who, "text": what, "refused": str(e)})
+            return
+        raise AssertionError(f"the demo expected a refusal: {what}")
+
+    curator, lab, ada, mallory, ruth = (g.author(x) for x in ("curator", "lab", "ada", "mallory", "ruth"))
+
+    # ── the question and the register ────────────────────────────────
+    inv = curator.investigation(TITLE, "Settle one disputed answer from the evidence everyone was given.",
+                                scope=f"The road register below: {len(ROADS)} roads between five towns, and the "
+                                      f"{n} routes from Kelso to Holme that visit no town twice.",
+                                reviewers=["ruth"])["id"]
+    q = curator.add("question", inv, text=QUESTION,
+                    why="Two parties disagree about the answer; the register holds what is known.")
+    say("curator", "Opens the question.", q)
+    src = {}
+    for i, (x, y, d) in enumerate(ROADS, 1):
+        src[f"E{i}"] = curator.add("source", inv, citation=f"Road register, item E{i}.",
+                                   passage=f"Road register: the road between {x} and {y} is {d} km long.",
+                                   reliability="The register given to every party.")["id"]
+    src["E7"] = curator.add("source", inv, citation="Road register, item E7: the units note.", passage=NOTE,
+                            reliability="The register given to every party.")["id"]
+    say("curator", f"Files the register: {len(ROADS)} roads and the units note (E1–E7).")
+
+    def count(figure: int, who: str) -> tuple[str, list[dict]]:
+        """The instrument counts the routes shorter than ``figure`` and files it as a run and a result."""
+        k = sum(1 for _p, d in all_routes if d < figure)
+        run = lab.add("run", inv, kind="lab", state="succeeded",
+                      name=f"Counted the routes from Kelso to Holme shorter than {figure} km, for {who}.",
+                      note="Every route that visits no town twice, enumerated from the register.")
+        res = lab.add("result", inv, kind="computed", outcome="positive",
+                      summary=f"{k} of {n} routes from Kelso to Holme are shorter than {figure} km.",
+                      values={"route_length": float(figure),
+                              "shorter_routes": {"k": k, "n": n, "figure": figure, "op": "<"}},
+                      links=[{"rel": "produced", "from": run["id"]}])
+        meas = [{"key": "route_length", "name": "route length", "value": float(figure), "result": res["id"]},
+                {"key": "shorter_routes", "name": f"routes shorter than {figure} km", "k": k, "n": n,
+                 "result": res["id"]}]
+        say("lab", f"Counts the routes shorter than {figure} km: {k} of {n}.", res)
+        return res["id"], meas
+
+    def cite(*eids: str, why: str) -> list[dict]:
+        return [{"rel": "supports", "from": src[e], "why": why} for e in eids]
+
+    # ── Ada: an honest mistake, shown and corrected ───────────────────
+    clock.set("2026-11-02", "10:00:00")
+    r30, m30 = count(30, "Ada")
+    claim30 = dict(statement="The shortest route from Kelso to Holme is 30 km (Kelso–Lydney–Elstow–Holme).",
+                   kind="finding", scope=f"The {n} routes from Kelso to Holme in the register.",
+                   measurements=m30,
+                   links=[{"rel": "answers", "to": q["id"]},
+                          *cite("E3", "E4", "E2", why="The three roads of the route, 14 + 9 + 7 km."),
+                          {"rel": "supports", "from": r30, "why": "The instrument's count at 30 km."}])
+    refused("ada", "Says the shortest route is 30 km. The count finds a shorter one.",
+            lambda: ada.add("claim", inv, **claim30))
+    clock.set("2026-11-02", "10:20:00")
+    r29, m29 = count(29, "Ada")
+    cl1 = ada.add("claim", inv, kind="finding", measurements=m29,
+                  statement=f"The shortest route from Kelso to Holme is 29 km (Kelso–Elstow–Holme); none of the {n} "
+                            f"routes is shorter than 29 km.",
+                  scope=f"The {n} routes from Kelso to Holme in the register.",
+                  links=[{"rel": "answers", "to": q["id"]},
+                         *cite("E1", "E2", why="The two roads of the route, 22 + 7 km."),
+                         *cite("E7", why="The note: the distances are kilometres, and roads run both ways."),
+                         {"rel": "supports", "from": r29, "why": "The instrument's count at 29 km."}])
+    say("ada", "Corrects it: 29 km, and none of the routes is shorter.", cl1)
+
+    # ── Mallory: the same lie, said again ─────────────────────────────
+    clock.set("2026-11-02", "11:00:00")
+    lie = dict(statement="The register's distances are recorded in miles, not kilometres, so Ada's answer for "
+                         "the shortest route doesn't stand.",
+               kind="finding", scope="The road register.",
+               links=[{"rel": "answers", "to": q["id"]},
+                      *cite("E7", why="The register's units note."),
+                      {"rel": "challenges", "to": cl1["id"], "why": "Disputes the answer's units."}])
+    refused("mallory", "Says the distances are in miles, citing the units note as support. The note says kilometres.",
+            lambda: mallory.add("claim", inv, **lie))
+    clock.set("2026-11-02", "11:10:00")
+    refused("mallory", "Says it again.", lambda: mallory.add("claim", inv, **lie))
+    clock.set("2026-11-02", "11:20:00")
+    cl2 = mallory.add("claim", inv, kind="finding", scope="The road register.",
+                      statement="The register's distances are recorded in miles, not kilometres, so Ada's answer for "
+                                "the shortest route doesn't stand.",
+                      links=[{"rel": "answers", "to": q["id"]},
+                             *cite("E1", "E2", why="The road lengths the answer adds up."),
+                             {"rel": "challenges", "to": cl1["id"], "why": "Disputes the answer's units."}])
+    say("mallory", "Drops the note and files the same claim against Ada's answer.", cl2)
+
+    # ── Ruth reads both against the register ──────────────────────────
+    clock.set("2026-11-02", "14:00:00")
+    ruth.review(cl1["id"], "checked", method="Added up every route in the register and read the units note.",
+                notes="29 km by Kelso–Elstow–Holme; no route is shorter; the note says kilometres.")
+    ruth.review(cl2["id"], "fail", method="Read the claim against the register's units note (E7).",
+                notes="E7 says every distance is in kilometres; nothing in the register says miles.")
+    say("ruth", "Checks Ada's claim and fails Mallory's.")
+    return g, inv, story

hypgraph-0.8.2/tests/test_demo_dispute.py

@@ -0,0 +1,52 @@
+"""The disputed-answer demo (hypgraph.demos.dispute): an honest mistake and a lie, told apart by the record alone.
+
+The README and the website show its Evidence view (one claim checked, the other contested) and its conduct log. These
+tests hold the demo to what those pages say: the refusals come from the record's own checks, the honest party ends
+cleared and the liar ends named, and the whole record verifies."""
+import json
+
+from hypgraph import cli
+from hypgraph.demos import DEMOS, dispute
+
+
+def test_the_routes_are_what_the_story_says():
+    assert [d for _p, d in dispute.routes()] == [29, 30, 45, 62]
+
+
+def test_each_refusal_is_the_records_own_check():
+    _g, _inv, story = dispute.build()
+    refused = [(s["actor"], s["refused"]) for s in story if "refused" in s]
+    assert [a for a, _ in refused] == ["ada", "mallory", "mallory"]
+    assert "[COUNT_CONTRADICTS]" in refused[0][1] and "1 of 4" in refused[0][1]
+    assert all("[SOURCE_CONTRADICTS]" in r and "kilometres" in r for _a, r in refused[1:])
+
+
+def test_the_reviewer_checks_one_answer_and_the_other_is_contested():
+    g, _inv, story = dispute.build()
+    codes = {s["code"]: s["node"] for s in story if s.get("code", "").startswith("CL")}
+    assert set(codes) == {"CL1", "CL2"}
+    assert g.get(codes["CL1"])["state"]["review"]["state"] == "checked"
+    assert g.get(codes["CL2"])["state"]["review"]["state"] == "contested"
+
+
+def test_the_conduct_log_clears_the_honest_party_and_names_the_liar():
+    g, inv, _ = dispute.build()
+    c = g.conduct(inv)
+    assert c["ada"]["corrected"] == 1 and c["ada"]["reasserted"] == 0
+    assert not c["ada"]["still_saying"] and not c["ada"]["ends_false"]
+    assert c["mallory"]["by_source"] == 1 and c["mallory"]["reasserted"] == 2 and c["mallory"]["corrected"] == 0
+    assert c["mallory"]["still_saying"] and c["mallory"]["ends_false"]
+
+
+def test_the_record_verifies(tmp_path):
+    g, _inv, _ = dispute.build(path=str(tmp_path / "d.hypgraph"))
+    assert g.verify()["ok"]
+
+
+def test_hypgraph_demo_dispute(tmp_path, capsys):
+    assert "dispute" in DEMOS
+    db = tmp_path / "d.hypgraph"
+    assert cli.main(["--db", str(db), "demo", "dispute", "--json"]) == 0
+    out = json.loads(capsys.readouterr().out)
+    assert out["conduct"]["mallory"]["ends_false"] and not out["conduct"]["ada"]["ends_false"]
+    assert sum("refused" in s for s in out["story"]) == 3

hypgraph-0.8.2/tests/test_quoted_counterexample.py

@@ -0,0 +1,107 @@
+"""An extreme that quotes its own counterexample is still false.
+
+"The shortest route is 30 km, since a count finds 1 of 77 shorter than 30 km" states the very count that refutes it.
+A stated count used to exempt an extreme whenever its clause said "k of n ... than", so the counterexample, quoted,
+made the claim pass. A count about a figure of the statement's own ("the shortest is 21 km; 1 of 77 are shorter than
+26 km") is still not an exception to the extreme. Invariants: quoting the refuting count never turns a refusal into an
+acceptance, with or without the figure on the result; the honest correction that quotes it is accepted; a count about
+another figure stays out of the way."""
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+
+SCOPE = "Every simple route between the two towns in the register (77 routes), distances in km."
+WHY = "The route counts bear on the claim."
+
+
+def outcome(values, statement, meas):
+    g = Graph(policy=Policy(reviewers={"critic"}))
+    inv = g.author("curator").investigation("Routes", "What is the shortest route between the two towns?")["id"]
+    lab = g.author("lab")
+    run = lab.add("run", inv, kind="lab", state="succeeded", name="Counted the routes.")
+    r = lab.add("result", inv, kind="computed", outcome="positive", summary="Counts of the routes.",
+                values=values, links=[{"rel": "produced", "from": run["id"]}])["id"]
+    try:
+        g.author("a").add("claim", inv, statement=statement, scope=SCOPE,
+                          measurements=[{**m, "result": r} for m in meas],
+                          links=[{"rel": "supports", "from": r, "why": WHY}])
+        return []
+    except GraphError as e:
+        return [p["code"] for p in e.problems] or [str(e)]
+
+
+def shorter(k, figure=None, n=77):
+    v = {"k": k, "n": n}
+    return v if figure is None else {**v, "figure": figure, "op": "<"}
+
+
+def case(figure):
+    """A route measured at 30 km and the instrument's count of routes shorter than it: 1 of 77. Named as the
+    instrument names it, with no figure in the name; the figure on the result or not."""
+    values = {"route_length": 30.0, "shorter_routes_connecting": shorter(1, figure)}
+    meas = [{"key": "route_length", "name": "route_length", "value": 30.0},
+            {"key": "shorter_routes_connecting", "name": "shorter routes connecting", "k": 1, "n": 77}]
+    return values, meas
+
+
+FIGURE = pytest.mark.parametrize("figure", [None, 30], ids=["no figure on the result", "figure on the result"])
+
+LIES = ["The shortest route is 30 km, since a count of every route that visits no town twice finds 1 of 77 shorter "
+        "than 30 km.",
+        "The shortest route is 30 km: 1 of 77 routes are shorter than 30 km.",
+        "The shortest route between the towns is 30 km, and 1 of 77 routes is shorter than 30 km."]
+
+
+@FIGURE
+@pytest.mark.parametrize("s", LIES)
+def test_an_extreme_quoting_its_own_counterexample_is_refused(s, figure):
+    assert "COUNT_CONTRADICTS" in outcome(*case(figure)[:1], s, case(figure)[1]), s
+
+
+@FIGURE
+def test_the_same_extreme_without_the_quote_is_refused(figure):
+    assert "COUNT_CONTRADICTS" in outcome(case(figure)[0], "The shortest route is 30 km.", case(figure)[1])
+
+
+@FIGURE
+@pytest.mark.parametrize("s", ["The shortest route is not 30 km, since a count of every route finds 1 of 77 shorter "
+                               "than 30 km.",
+                               "30 km is not the shortest route: 1 of 77 routes are shorter than 30 km."])
+def test_the_correction_that_quotes_the_count_is_accepted(s, figure):
+    assert outcome(case(figure)[0], s, case(figure)[1]) == [], s
+
+
+def test_a_count_about_another_figure_is_not_an_exception_to_the_extreme():
+    """The count beyond 26 the statement gives says nothing against "the shortest is 21"; the count at 21 backs it."""
+    s = "The shortest route is 21 km; 1 of 77 routes are shorter than 26 km."
+    values = {"route_length": 21.0, "shorter_than_21": shorter(0, 21), "shorter_than_26": shorter(1, 26)}
+    meas = [{"key": "route_length", "name": "route_length", "value": 21.0},
+            {"key": "shorter_than_21", "name": "routes shorter than 21 km", "k": 0, "n": 77},
+            {"key": "shorter_than_26", "name": "routes shorter than 26 km", "k": 1, "n": 77}]
+    assert "COUNT_CONTRADICTS" not in outcome(values, s, meas)
+
+
+# Two readings the quoted-count exemption used to hide: once a quoted count no longer excuses an extreme, an honest
+# sentence must not be read as claiming one.
+
+@FIGURE
+@pytest.mark.parametrize("s", ["The shortest route is therefore not 30 km: 1 of 77 routes are shorter than 30 km.",
+                               "1 of 77 routes are shorter than 30 km, so 30 km is therefore not the shortest route.",
+                               "A count finds 1 of 77 routes shorter than 30 km; the shortest route is thus not 30 km."])
+def test_a_denial_with_an_adverb_is_a_correction(s, figure):
+    assert outcome(case(figure)[0], s, case(figure)[1]) == [], s
+
+
+@FIGURE
+@pytest.mark.parametrize("s", ["The shortest route is at most 30 km: 1 of 77 routes are shorter than 30 km.",
+                               "The shortest route is 30 km or less; 1 of 77 routes are shorter than 30 km."])
+def test_a_bound_in_the_extremes_own_direction_is_not_its_value(s, figure):
+    """At most 30 km, with a route shorter than 30 found, is true: the bound is not a claim that 30 is the shortest."""
+    assert "COUNT_CONTRADICTS" not in outcome(case(figure)[0], s, case(figure)[1]), s
+
+
+@FIGURE
+def test_a_bound_the_other_way_still_claims_its_figure(figure):
+    """At least 30 km, with a route shorter than 30 found, is false."""
+    s = "The shortest route is at least 30 km."
+    assert "COUNT_CONTRADICTS" in outcome(case(figure)[0], s, case(figure)[1])