hypgraph 0.7.26__tar.gz → 0.7.27__tar.gz

{hypgraph-0.7.26 → hypgraph-0.7.27}/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.7.27 — 2026-11-01: words said elsewhere, comparisons the checks didn't know
+
+Fixes from an independent audit of 0.7.26 (HG-026-01, -02); each case below failed on 0.7.26 and is now a test
+(`tests/test_borrowed_words.py`).
+
+- **A word said in another clause doesn't make a count fit** (HG-026-01). What a count's key says it counted had to be
+  said by the measurement's name or anywhere in the statement, so "Speed was recorded separately; no route is longer
+  than 26 km" let a speed count named "routes longer than 26 km" back the length claim, and "Cargo routes were
+  inspected; no passenger route is longer …" did the same for a cargo count. The words must now be said where the
+  claim states the count's figure (its clause, from the comma before its absolute or extreme). Eight paraphrases over
+  other subjects and properties, written after the fix, are tests too: an extra clause never turns a refusal into an
+  acceptance, and an honest count backs the claim with or without one.
+- **Any comparison makes an absolute** (HG-026-01, found while reproducing it). "No crate is heavier than 40 kg" and "no
+  shift had errors above 5" weren't read as absolutes, so they went in with no count, or with a count of crate prices.
+  "No …" before any comparison word is now an absolute; heavier / lighter, warmer / colder, older / younger, taller,
+  wider, deeper, louder and stronger are comparisons along their own axes (weight, temperature, age, height, width,
+  depth, loudness, strength), and a comparative the checks don't know ("brighter than") is met only by a count that
+  says the same word. A three-letter word before a comparison ("bridge age above 60") now names what was counted, and
+  "span" is a length, so an honest count of bridge spans backs "no bridge is longer than 60 m".
+- **A mixed "and" / "or" clause has to be split** (HG-026-02). 0.7.26's notes said such a clause is unresolved "until a
+  count of the whole condition is bound"; nothing ties a count to the whole condition, so that never happened. The
+  refusal now says to split the claim into clauses that each join their comparisons one way.
+
 ## 0.7.26 — 2026-11-01: what a count is of, what its key compared, "and" with "or"
 
 Fixes from an independent audit of 0.7.25 (HG-025-01 to -03); each case below failed on 0.7.25 and is now a test

{hypgraph-0.7.26 → hypgraph-0.7.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.7.26
+Version: 0.7.27
 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.26 → hypgraph-0.7.27}/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.7.26 (2026-11-01)
+## Status at 0.7.27 (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.7.26 → hypgraph-0.7.27}/docs/RELEASE-READINESS.md

@@ -181,6 +181,21 @@ was taken from a changelog without being checked against the code.*
 > **Where that stands.** #96 is merged with green CI (17 of 17 checks). Kinds and subjects are still read from the
 > words around a comparison, a heuristic; the typed claim layer the audits recommend is not built. Released as 0.7.26.
 
+> **Audit of 0.7.26 (2026-11-01), fixed for 0.7.27.** A seventh independent audit named two defects; both reproduced on
+> the PyPI 0.7.26 wheel. A clause that only mentioned speed ("Speed was recorded separately; no route is longer than
+> 26 km") let a speed count named "routes longer than 26 km" back the length claim, and the same for cargo named as
+> passenger routes: the key's words were looked for anywhere in the statement (HG-026-01). Reproducing it found a
+> wider gap: "no crate is heavier than 40 kg" wasn't read as an absolute, so it went in with no count or with a count
+> of crate prices. And the 0.7.26 note that a count of the whole condition settles a mixed "and" / "or" clause promised
+> something nothing implements (HG-026-02). A key's words must now be said where the claim states the count's figure;
+> "no …" before any comparison is an absolute; eight more comparison pairs have axes of their own, and an unknown
+> "-er than" is met only by a count saying the same word; the mixed-clause refusal says to split the claim. Eleven
+> paraphrases written after the first fix found three more gaps (a three-letter subject, "span", a comma-led aside),
+> fixed before merge. Replaying the 1,900 recorded adversarial entries changes none.
+>
+> **Where that stands.** #98 is merged with green CI (17 of 17 checks). This is still word matching; the typed claim
+> layer the audits recommend is not built. Released as 0.7.27.
+
 ## 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.7.26 → hypgraph-0.7.27}/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.26"
+__version__ = "0.7.27"
 
 from .bundle import anchored, verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.7.26 → hypgraph-0.7.27}/src/hypgraph/checks.py

@@ -243,7 +243,7 @@ def _bound(s: Snap, meas: list, stmt: str = "") -> tuple[list[tuple[dict, dict]]
             bad = True
         # a name that says no comparison ("fitting selections") doesn't say another count; one that does must keep
         # what the key counted, here or in the statement
-        unsaid = _unsaid(_subject_of(key), f"{m.get('name') or ''} . {stmt}")
+        unsaid = _unsaid(_subject_of(key), f"{m.get('name') or ''} . {_clauses_at(stmt, _count_figures(m, rv))}")
         if not bad and unsaid and _comparisons_in(str(m.get("name") or "")):
             problems.append(Problem("MEASUREMENT_MISMATCH", f"measurement {m.get('name')}: result {m['result']} "
                                     f"counted '{m['key']}', and neither the name nor the statement says what it "
@@ -256,6 +256,32 @@ def _bound(s: Snap, meas: list, stmt: str = "") -> tuple[list[tuple[dict, dict]]
     return good, problems
 
 
+# where one thing said ends and another begins: a sentence, a semicolon or colon, or a comma before a conjunction
+_SAYING = re.compile(r"[;:!?]|\.(?!\d)|,\s*(?=(?:and|but|while|whereas|although|though|so|yet)\b)|"
+                     r"\b(?:although|though|whereas)\b", re.I)
+
+
+def _clauses_at(stmt: str, figs: set[float]) -> str:
+    """The parts of ``stmt`` that state one of ``figs``: what a count against that figure must be about is said there,
+    not in another sentence. "Speed was recorded separately; no route is longer than 26 km" says nothing about speed
+    where it says 26 km, so a speed count named "routes longer than 26 km" can't borrow the word (audit HG-026-01).
+    The whole statement when no part states one."""
+    if not stmt or not figs:
+        return stmt
+    parts = [p for p in _SAYING.split(stmt) if p and p.strip()]
+    hit = [_from_claim(p) for p in parts if {round(v[0], 6) for v in numbers(p)} & {round(f, 6) for f in figs}]
+    return " . ".join(hit) if hit else stmt
+
+
+def _from_claim(part: str) -> str:
+    """A part from the comma before its absolute or extreme: "Rural sites aside, no urban clinic had waits above 45"
+    claims only "no urban clinic had waits above 45"."""
+    hit = L.ABSOLUTE.search(part) or L.SUPERLATIVE.search(part)
+    if not hit:
+        return part
+    return part[max((x.end() for x in re.finditer(r",(?!\d)", part[:hit.start()])), default=0):]
+
+
 def _axis_words(axes: set[str]) -> str:
     return " / ".join(sorted("/".join(w for w, (a, _s) in _DIRECTION_OF.items() if a == x and not w.endswith("est"))
                              for x in axes))
@@ -309,13 +335,11 @@ _PROVEN = re.compile(r"^prov(?:es?|en|ed)$|^proof$", re.I)
 
 # the figure a count is about: "fitting selections worth more than 93", "routes shorter than 26 km" (or, matching a
 # figure the claim names, "worth_more_93"). A count of nothing beyond 140 says nothing about 93 (audit HG-020-01/02).
-_COUNT_FIGURE = re.compile(r"\b(?:(?:more|less|fewer|greater|higher|lower|better|worse|shorter|longer|cheaper|faster|"
-                           r"slower|larger|smaller)\s+than|above|below|over|under|beyond|exceed\w*|beat\w*)\s+\$?"
+_COUNT_FIGURE = re.compile(r"\b(?:(?:" + L.CMP_WORDS + r"|(?!(?:" + L.NOT_CMP + r")\b)[a-z]{3,}er)\s+than|above|below|over|under|beyond|exceed\w*|beat\w*)\s+\$?"
                            r"(-?\d[\d,]*(?:\.\d+)?)", re.I)
 # the figure a name gives before its comparison or with "at least": "routes 26 km or longer", "routes at least 26 km"
 _COUNT_FIGURE_BOUNDARY = re.compile(r"\bat\s+(?:least|most)\s+\$?(-?\d[\d,]*(?:\.\d+)?)|\$?(-?\d[\d,]*(?:\.\d+)?)"
-                                    r"(?:\s+[a-z%]+){0,2}\s+or\s+(?:more|less|fewer|greater|higher|lower|better|worse|"
-                                    r"shorter|longer|cheaper|faster|slower|larger|smaller)\b", re.I)
+                                    r"(?:\s+[a-z%]+){0,2}\s+or\s+(?:" + L.CMP_WORDS + r")\b", re.I)
 
 
 def _named_figure(name: str) -> tuple[float, str] | None:
@@ -329,16 +353,13 @@ def _named_figure(name: str) -> tuple[float, str] | None:
     return None
 
 
-_KEY_FIGURE = re.compile(r"\b(?:more|less|fewer|greater|higher|lower|better|worse|shorter|longer|cheaper|faster|"
-                         r"slower|larger|smaller|above|below|over|under|beyond|exceed\w*|beat\w*)(?:\s+than)?\s+"
+_KEY_FIGURE = re.compile(r"\b(?:" + L.CMP_WORDS + r"|above|below|over|under|beyond|exceed\w*|beat\w*)(?:\s+than)?\s+"
                          r"(\d+(?:\.\d+)?)$", re.I)
 # the figure an absolute names in its own clause: "nothing worth more than 93 fits", "no route is shorter than 26 km"
-_CLAIM_FIGURE = re.compile(r"\b(?:more|less|fewer|greater|higher|lower|better|worse|shorter|longer|cheaper|faster|"
-                           r"slower|larger|smaller)\s+than\s+\$?(-?\d[\d,]*(?:\.\d+)?)|\b(?:above|below|beyond|"
+_CLAIM_FIGURE = re.compile(r"\b(?:" + L.CMP_WORDS + r"|(?!(?:" + L.NOT_CMP + r")\b)[a-z]{3,}er)\s+than\s+\$?(-?\d[\d,]*(?:\.\d+)?)|\b(?:above|below|beyond|"
                            r"exceed(?:s|ing)?)\s+\$?(-?\d[\d,]*(?:\.\d+)?)", re.I)
 _CLAIM_BOUNDARY = re.compile(r"\bat\s+(?:least|most)\s+\$?(-?\d[\d,]*(?:\.\d+)?)|\$?(-?\d[\d,]*(?:\.\d+)?)"
-                             r"(?:\s+[a-z%]+){0,2}\s+or\s+(?:more|less|fewer|greater|higher|lower|better|worse|"
-                             r"shorter|longer|cheaper|faster|slower|larger|smaller)\b", re.I)
+                             r"(?:\s+[a-z%]+){0,2}\s+or\s+(?:" + L.CMP_WORDS + r")\b", re.I)
 _SUBCLAUSE = re.compile(r",(?!\d)|[;:!?()]|\.(?!\d)|\b(?:and|but|while|whereas|although|so)\b", re.I)
 
 
@@ -382,6 +403,14 @@ _DIRECTION_WORDS = {
     "fast": {1: "faster fastest", -1: "slower slowest"},
     "cost": {1: "dearer dearest", -1: "cheaper cheapest"},
     "time": {1: "later latest", -1: "earlier earliest"},
+    "heavy": {1: "heavier heaviest", -1: "lighter lightest"},
+    "warm": {1: "warmer warmest hotter hottest", -1: "colder coldest cooler coolest"},
+    "old": {1: "older oldest", -1: "younger youngest newer newest"},
+    "tall": {1: "taller tallest"},
+    "wide": {1: "wider widest", -1: "narrower narrowest"},
+    "deep": {1: "deeper deepest", -1: "shallower shallowest"},
+    "loud": {1: "louder loudest", -1: "quieter quietest"},
+    "strong": {1: "stronger strongest", -1: "weaker weakest"},
 }
 _DIRECTION_OF = {w: (axis, sign) for axis, signs in _DIRECTION_WORDS.items() for sign, ws in signs.items()
                  for w in ws.split()}
@@ -389,8 +418,7 @@ _DIRECTION_OF = {w: (axis, sign) for axis, signs in _DIRECTION_WORDS.items() for
 # not strict, so a route of exactly 26 lies inside them and outside "longer than" (audit HG-023-02). Six operators;
 # "=" and "!=" point nowhere.
 _OPS = {">": (1, True), ">=": (1, False), "<": (-1, True), "<=": (-1, False), "=": None, "!=": None}
-_CMP = r"(more|less|fewer|greater|higher|lower|better|worse|shorter|longer|cheaper|dearer|faster|slower|larger|" \
-       r"smaller|bigger|earlier|later)"
+_CMP = r"(" + L.CMP_WORDS + r")"
 _NOT_STRICT = re.compile(r"\bat\s+(least|most)\b|\b(?:not|no)\s+" + _CMP + r"\s+than\b|\bor\s+" + _CMP + r"\b", re.I)
 
 
@@ -408,7 +436,13 @@ def _comparisons_in(text: str) -> set[tuple[str, int, bool]]:
         else:
             out.add((*_DIRECTION_OF[h.group(3)], False))
     rest = _NOT_STRICT.sub(" ", text)
-    return out | {(*_DIRECTION_OF[w], True) for w in re.findall(r"[a-z]+", rest) if w in _DIRECTION_OF}
+    # a comparative the checks don't know ("brighter than") is an axis of its own: only a count that says the same word
+    # meets it, so nothing else can back a claim made with it (audit HG-026-01)
+    unknown = {(w, 1, True) for w in _UNKNOWN_CMP.findall(rest) if w not in _DIRECTION_OF}
+    return out | unknown | {(*_DIRECTION_OF[w], True) for w in re.findall(r"[a-z]+", rest) if w in _DIRECTION_OF}
+
+
+_UNKNOWN_CMP = re.compile(r"\b(?!(?:" + L.NOT_CMP + r")\b)([a-z]{3,}er)\s+than\b")
 
 
 def _directions(text: str) -> set[tuple[str, int]]:
@@ -582,12 +616,23 @@ _COUNTING = set("count counts counted counting number numbers total totals tally
 _HOW_MANY = set("nothing none never nobody every always ever each whole entire".split())
 
 
+# three-letter words that say nothing about what was counted
+_SHORT_SKIP = set("has had did got get let may can one two six ten few new old top max min own via nor yet per".split())
+
+
+def _stems(text: str) -> set[str]:
+    """``L.content_words`` and the three-letter words it leaves out, which can name what was counted: a count of
+    "bridge age above 60" is of ages, and "age" must be said for it to back a claim (audit HG-026-01)."""
+    return L.content_words(text) | {w for w in re.findall(r"[a-z]+", (text or "").lower())
+                                    if len(w) == 3 and w not in L.STOP and w not in _SHORT_SKIP}
+
+
 def _modifiers(words: list[str], i: int) -> set[str]:
     """The content words right before ``words[i]``, up to a determiner, number, preposition or comparison: "no passenger
     route" gives {passeng}, "the 3 cargo routes" {cargo}, "the shortest route" nothing."""
     out: set[str] = set()
     for w in reversed(words[:i]):
-        cw = L.content_words(w)
+        cw = _stems(w)
         if not cw or w in _DETERMINERS or w in _PREPOSITIONS or w in _DIRECTION_OF or w in _COUNTING | _HOW_MANY:
             break
         out |= cw
@@ -616,7 +661,7 @@ def _subject_parts(text: str) -> tuple[set[str], set[str]]:
     while i > 1 and words[i - 1] in _MEASURED_BY:      # "selections worth more": the head is selections
         whole -= L.content_words(words[i - 1])
         i -= 1
-    head = L.content_words(words[i - 1]) & whole
+    head = _stems(words[i - 1]) & whole
     return head, whole - head
 
 
@@ -626,15 +671,18 @@ _MEASURED_BY = set("worth valued priced weighing costing lasting taking".split()
 
 _COPULAS = set("is are was were be been being".split())
 # the property a comparison word compares: a count of "route length above 26" is said by "no route is longer than 26"
-_PROPERTY_AXIS = {s: axis for axis, ws in {"long": "length distance", "fast": "speed velocity pace",
-                                           "cost": "cost price", "time": "date time"}.items()
-                  for w in ws.split() for s in L.content_words(w)}
+_PROPERTY_AXIS = {s: axis for axis, ws in {"long": "length distance span", "fast": "speed velocity pace",
+                                           "cost": "cost price", "time": "date time", "heavy": "weight mass",
+                                           "warm": "temperature heat", "old": "age", "tall": "height",
+                                           "wide": "width breadth", "deep": "depth", "loud": "loudness",
+                                           "strong": "strength"}.items()
+                  for w in ws.split() for s in _stems(w)}
 
 
 def _unsaid(stems: set[str], text: str) -> set[str]:
     """``stems`` that ``text`` doesn't say: neither as words nor, for a property, by comparing along its axis."""
     axes = {c[0] for c in _comparisons_in(text) if c[0]}
-    return {s for s in stems - L.content_words(text) if _PROPERTY_AXIS.get(s) not in axes}
+    return {s for s in stems - _stems(text) if _PROPERTY_AXIS.get(s) not in axes}
 
 
 def _subjects_at(stmt: str, axes: set[str]) -> set[str]:
@@ -733,9 +781,10 @@ def _absolutes(stmt: str, scope: str, body: dict, bound: list) -> list[Problem]:
             seen.add((tuple(group), _ALL.match(w) is None))
             if group[0] is MIXED:
                 p = Problem("ABSOLUTE_WITHOUT_COUNT", f"'{w}' rules on comparisons joined by both 'and' and 'or': "
-                            "counts of each comparison on its own can't settle that either way. Count what meets the "
-                            "whole condition, or split it into claims that each join their comparisons one way",
-                            fix="count what meets the whole condition, or split the claim", words=words)
+                            "counts of each comparison on its own can't settle that either way, and no count can be "
+                            "tied to the whole condition. Split it into claims that each join their comparisons one "
+                            "way (audit HG-026-02)",
+                            fix="split the claim into clauses that each join their comparisons one way", words=words)
                 if p.text() not in {q.text() for q in out}:
                     out.append(p)
                 continue
@@ -860,8 +909,7 @@ def _denied(after: str) -> bool:
 
 # a count named for what lies beyond a figure ("fitting selections worth more", "shorter routes connecting") is about
 # any extreme the statement claims, whatever words the statement uses for it ("the highest total value is 99")
-_BEYOND = re.compile(r"\b(?:more|less|fewer|greater|higher|lower|better|worse|shorter|longer|cheaper|faster|slower|"
-                     r"larger|smaller|above|below|exceed\w*|beat\w*)\b", re.I)
+_BEYOND = re.compile(r"\b(?:" + L.CMP_WORDS + r"|above|below|exceed\w*|beat\w*)\b", re.I)
 
 
 def _extremes(stmt: str) -> list[str]:

{hypgraph-0.7.26 → hypgraph-0.7.27}/src/hypgraph/language.py

@@ -14,6 +14,12 @@ from __future__ import annotations
 
 import re
 
+# every comparative the checks know, and the "-er than" words that aren't one ("other than", "rather than")
+CMP_WORDS = ("longer|shorter|more|less|fewer|greater|higher|lower|larger|smaller|bigger|better|worse|faster|slower|"
+             "cheaper|dearer|earlier|later|heavier|lighter|warmer|hotter|colder|cooler|older|younger|newer|taller|wider|"
+             "narrower|deeper|shallower|louder|quieter|stronger|weaker")
+NOT_CMP = "other|rather|either|neither|whether|never|ever|over|under|after|per|number|order|matter"
+
 ABSOLUTE = re.compile(
     r"\b(never|always|all|every|none|nothing|no one|nobody|impossible|cannot|can't|proves?|proven|proof|certainly|"
     r"certain|guaranteed?|guarantees|eliminat(?:es|ed|ing)|entirely|completely|totally|universally|invariably|"
@@ -22,14 +28,16 @@ ABSOLUTE = re.compile(
     # "no route is longer than 26 km": a universal negative comparison, the same claim as "nothing is longer"; only
     # where "no" opens its clause ("routes that visit no town twice" is not one); "no route is 26 km or longer" and
     # "no route is at least 26 km" too
-    r"|(?<![a-z] )no(?=\s+(?:[a-z]+\s+){1,3}?(?:is|are|was|were)\s+(?:any\s+)?(?:at\s+(?:least|most)\s|"
-    r"\$?\d[\d,.]*(?:\s+[a-z%]+){0,2}\s+or\s+(?:longer|shorter|more|less|fewer|greater|higher|lower|larger|smaller|"
-    r"better|worse|faster|slower|cheaper)\b|(?:longer|shorter|more|less|fewer|greater|higher|lower|larger|smaller|"
-    r"better|worse|faster|slower|cheaper|above|below|over|under)\b)))\b|(?<![\d.])100\s*%", re.I)
+    # Any comparison word, and any verb before it: "no crate is heavier than 40 kg", "no shift had errors above 5",
+    # "no crate weighs more than 40 kg" (audit HG-026-01: these went unread, so any count backed them)
+    r"|(?<![a-z] )no(?=\s+(?:[a-z]+\s+){1,4}?(?:(?:is|are|was|were)\s+(?:any\s+)?)?(?:at\s+(?:least|most)\s|"
+    r"\$?\d[\d,.]*(?:\s+[a-z%]+){0,2}\s+or\s+(?:" + CMP_WORDS + r")\b|(?:" + CMP_WORDS + r"|above|below|over|under|"
+    r"exceed(?:s|ed|ing)?)\b|(?!(?:" + NOT_CMP + r")\b)[a-z]{3,}er\s+than\b)))\b|(?<![\d.])100\s*%", re.I)
 # a superlative names an extreme ("the highest value is 93"): a count of anything beyond it contradicts it
 SUPERLATIVE = re.compile(
     r"\b(highest|lowest|largest|smallest|shortest|longest|greatest|fewest|best|worst|maximum|minimum|optimal|"
-    r"optimum|cheapest|fastest|slowest|biggest|earliest|latest)\b", re.I)
+    r"optimum|cheapest|fastest|slowest|biggest|earliest|latest|heaviest|lightest|warmest|hottest|coldest|coolest|"
+    r"oldest|youngest|newest|tallest|widest|narrowest|deepest|shallowest|loudest|quietest|strongest|weakest)\b", re.I)
 COMPARATIVE = re.compile(
     r"\b(better|worse|beats?|beat|outperform(?:s|ed|ing)?|underperform(?:s|ed|ing)?|improv(?:es|ed|ement|ing)|"
     r"superior|inferior|exceeds?|exceeded|higher than|lower than|more than|fewer than|less than|faster|slower|"

hypgraph-0.7.27/tests/test_borrowed_words.py

@@ -0,0 +1,130 @@
+"""A word said somewhere else in the statement, and a comparison the checks didn't know (audit of 0.7.26, HG-026-01
+and -02).
+
+A count's key says what was counted; the claimant's name for it must keep that, here or where the claim states the
+count's figure. "Speed was recorded separately; no route is longer than 26 km" says nothing about speed where it says
+26 km, so a speed count named "routes longer than 26 km" can't borrow the word. The invariant: an extra clause never
+turns a refusal into an acceptance, and an honest count backs the claim with or without it. "No crate is heavier than
+40 kg" is an absolute like "no route is longer than 26 km", and a comparison the checks don't know ("brighter than")
+is met only by a count that says the same word."""
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+
+SCOPE = "The surveyed items, against the stated mark."
+
+
+def outcome(values, statement, meas=()):
+    g = Graph(policy=Policy(reviewers={"critic"}))
+    inv = g.author("curator").investigation("Survey", "What do the surveyed items show?")["id"]
+    lab = g.author("lab")
+    run = lab.add("run", inv, kind="lab", state="succeeded", name="Measured the surveyed items.")
+    r = lab.add("result", inv, kind="computed", outcome="positive", summary="Counts of the surveyed items.",
+                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": "Cited for the claim."}])
+        return []
+    except GraphError as e:
+        return [p["code"] for p in e.problems]
+
+
+def t(k, figure, op=">", n=3):
+    return {"k": k, "n": n, "figure": figure, "op": op}
+
+
+def M(key, name, k, n=3):
+    return {"name": name, "key": key, "k": k, "n": n}
+
+
+# (frozen values, the relabelled count, the claim, the claim with the borrowed word said elsewhere)
+LAUNDER = {
+    "speed as length": ({"route_speed_above_26": t(0, 26)}, M("route_speed_above_26", "routes longer than 26 km", 0),
+                        "No route is longer than 26 km among the 3 routes.",
+                        ["Speed was recorded separately; no route is longer than 26 km among the 3 routes."]),
+    "cargo as passenger": ({"cargo_route_longer_26": t(0, 26), "passenger_route_longer_26": t(1, 26)},
+                           M("cargo_route_longer_26", "passenger route longer than 26 km", 0),
+                           "No passenger route is longer than 26 km among the 3 routes.",
+                           ["Cargo routes were inspected; no passenger route is longer than 26 km among the 3 "
+                            "routes."]),
+    "night as day": ({"night_shift_errors_above_5": t(0, 5), "day_shift_errors_above_5": t(3, 5)},
+                     M("night_shift_errors_above_5", "day shift errors above 5", 0),
+                     "No day shift had errors above 5 among the 3 shifts.",
+                     ["The night shift was audited separately; no day shift had errors above 5 among the 3 shifts."]),
+    "price as weight": ({"crate_price_above_40": t(0, 40)}, M("crate_price_above_40", "crates heavier than 40 kg", 0),
+                        "No crate is heavier than 40 kg among the 3 crates.",
+                        ["Prices were logged too; no crate is heavier than 40 kg among the 3 crates."]),
+    "frozen as fresh": ({"frozen_sample_warmer_8": t(0, 8), "fresh_sample_warmer_8": t(2, 8)},
+                        M("frozen_sample_warmer_8", "fresh sample warmer than 8 C", 0),
+                        "No fresh sample is warmer than 8 C among the 3 samples.",
+                        ["Frozen samples were checked as well; no fresh sample is warmer than 8 C among the 3 "
+                         "samples."]),
+    "age as span": ({"bridge_age_above_60": t(0, 60)}, M("bridge_age_above_60", "bridges longer than 60 m", 0),
+                    "No bridge is longer than 60 m among the 3 bridges.",
+                    ["Ages were taken from the register. No bridge is longer than 60 m among the 3 bridges.",
+                     "Although age was recorded, no bridge is longer than 60 m among the 3 bridges.",
+                     "We noted each bridge's age, and no bridge is longer than 60 m among the 3 bridges."]),
+    "rural as urban": ({"rural_clinic_waits_above_45": t(0, 45), "urban_clinic_waits_above_45": t(3, 45)},
+                       M("rural_clinic_waits_above_45", "urban clinic waits above 45 minutes", 0),
+                       "No urban clinic had waits above 45 minutes among the 3 clinics.",
+                       ["Rural clinics were visited first; no urban clinic had waits above 45 minutes among the 3 "
+                        "clinics.",
+                        "Rural sites aside, no urban clinic had waits above 45 minutes among the 3 clinics."]),
+    "unknown comparison": ({"lamp_wattage_above_40": t(0, 40)}, M("lamp_wattage_above_40", "lamps brighter than 40 lux",
+                                                                  0),
+                           "No lamp is brighter than 40 lux among the 3 lamps.",
+                           ["Wattage was read off each label. No lamp is brighter than 40 lux among the 3 lamps."]),
+}
+
+
+@pytest.mark.parametrize("case", list(LAUNDER))
+def test_a_word_said_elsewhere_does_not_launder_a_count(case):
+    """HG-026-01: the missing word was looked for anywhere in the statement, so a clause that only mentioned speed (or
+    cargo, or the night shift) let a count of it back a claim about something else."""
+    values, m, claim, padded = LAUNDER[case]
+    assert "MEASUREMENT_MISMATCH" in outcome(values, claim, [m])
+    for s in padded:
+        assert "MEASUREMENT_MISMATCH" in outcome(values, s, [m]), s
+
+
+HONEST = [
+    ({"passenger_route_longer_26": t(0, 26)}, M("passenger_route_longer_26", "passenger routes longer than 26 km", 0),
+     ["No passenger route is longer than 26 km among the 3 routes.",
+      "Cargo routes were inspected; no passenger route is longer than 26 km among the 3 routes."]),
+    ({"bridge_span_above_60": t(0, 60)}, M("bridge_span_above_60", "bridge spans above 60 m", 0),
+     ["No bridge is longer than 60 m among the 3 bridges.",
+      "Ages were taken from the register. No bridge is longer than 60 m among the 3 bridges."]),
+    ({"well_temperature_above_30": t(0, 30)}, M("well_temperature_above_30", "well temperature above 30 C", 0),
+     ["No well is warmer than 30 C among the 3 wells.",
+      "Depth was logged: no well is warmer than 30 C among the 3 wells."]),
+    ({"crate_weight_above_40": t(0, 40)}, M("crate_weight_above_40", "crates heavier than 40 kg", 0),
+     ["No crate is heavier than 40 kg among the 3 crates.",
+      "Prices were logged too; no crate is heavier than 40 kg among the 3 crates."]),
+    ({"lamps_brighter_than_40": t(0, 40)}, M("lamps_brighter_than_40", "lamps brighter than 40 lux", 0),
+     ["No lamp is brighter than 40 lux among the 3 lamps."]),
+]
+
+
+@pytest.mark.parametrize("i", range(len(HONEST)))
+def test_an_honest_count_backs_the_claim_with_or_without_another_clause(i):
+    values, m, statements = HONEST[i]
+    for s in statements:
+        assert outcome(values, s, [m]) == [], s
+
+
+@pytest.mark.parametrize("s", ["No crate is heavier than 40 kg among the 3 crates.",
+                               "No lamp is brighter than 40 lux among the 3 lamps.",
+                               "No shift had errors above 5 among the 3 shifts."])
+def test_an_absolute_with_any_comparison_needs_a_count(s):
+    """These weren't read as absolutes, so the record took them with no count at all, or with a count of anything."""
+    assert "ABSOLUTE_WITHOUT_COUNT" in outcome({"other": t(0, 1)}, s)
+
+
+def test_a_count_cannot_be_tied_to_a_mixed_condition():
+    """HG-026-02: 0.7.26's notes said a count of the whole condition would settle a mixed "and" / "or" clause; nothing
+    ties a count to it, so the refusal says to split the claim."""
+    values = {"longer_10_and_shorter_30_or_shorter_6": t(3, 10), "longer_10": t(2, 10)}
+    codes = outcome(values, "Every route is longer than 10 km and shorter than 30 km or shorter than 6 km among the 3 "
+                            "routes.", [M("longer_10", "routes longer than 10 km", 2)])
+    assert "ABSOLUTE_WITHOUT_COUNT" in codes