hypgraph 0.7.27__tar.gz → 0.7.28__tar.gz

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

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.7.28 — 2026-11-01: a figure said twice, a comparison in another tense
+
+Fixes from an independent audit of 0.7.27 (HG-027-01, -02) and from paraphrases written after the first fix; each case
+below failed on 0.7.27 and is now a test (`tests/test_figure_said_twice.py`, 22 of its 34 cases fail on 0.7.27).
+
+- **A figure said in a clause that claims nothing doesn't lend it words** (HG-027-01). 0.7.27 read every clause that
+  stated a count's figure for what the count was about, so "Speed was recorded above 26 separately; no route is longer
+  than 26 km" still let a speed count named "routes longer than 26 km" back the length claim, and cargo counts back
+  passenger claims the same way. Of the clauses that state the figure, only those that make the claim (an absolute or
+  an extreme) are read now, when any does.
+- **A comparison is read the same in every tense** (HG-027-02). "No route exceeded 26 km" was an absolute, but its
+  figure went unread ("exceeds" was read, "exceeded" wasn't), so any complete count backed it, even beside a count of 1
+  route over 26. Every stage now reads one list: "exceed" and "surpass" in every tense, "above", "below", "beyond", and
+  "over" / "under" after "is" / "was" or the noun "no" opens ("no route under 20 km exists"); not "over 1000 runs",
+  which says how many were run. A comparison whose figure still can't be read ("no route is longer than the usual
+  one") is backed only by a count that makes that comparison, never by one that compares nothing.
+- **"None of the 4 routes" is still contradicted by its count.** An absolute over a set the sentence enumerates needs no
+  count of its own, but it used to skip the check entirely, so a bound count of 1 route over 26 went unread. A count
+  that finds an exception now contradicts an enumerated "none" or "neither". An enumerated "all" / "every" stays
+  exempt: in the recorded entries it names the set a count ran over ("across all 1,024 selections, 2 fit").
+- **One count backs "no route exceeds 26 km".** "Exceeds" with a figure inside an absolute is a bound the absolute check
+  settles, not two measured things compared; the comparison check no longer asks for a second measurement there.
+- Replaying the 1,900 recorded adversarial entries changes none, and every trial's standing is the same. This is
+  still word matching: the typed claim layer the audits recommend is not built.
+
 ## 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

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

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

@@ -196,6 +196,23 @@ was taken from a changelog without being checked against the code.*
 > **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.
 
+> **Audit of 0.7.27 (2026-11-01), fixed for 0.7.28.** An eighth independent audit named two defects; both reproduced
+> on the PyPI 0.7.27 wheel (7 of the audit's 9 cases failed, its 2 controls passed). Repeating the count's figure in a
+> clause that claims nothing ("Speed was recorded above 26 separately; no route is longer than 26 km") still let that
+> clause's words say what the count was of (HG-027-01). And "no route exceeded 26 km" was read as an absolute without
+> its figure, so a complete count of anything backed it, even beside a counted counterexample (HG-027-02). Only the
+> clauses that make the claim are read now; every stage reads one list of comparison words in every tense; a
+> comparison whose figure can't be read is backed only by a count that makes it. Holdout paraphrases written after the
+> first fix found three more gaps, fixed before merge: an enumerated "none of the 4 routes" skipped the check, so a
+> counterexample went unread; "over 1000 runs" must not read as a bound; and one honest count was refused for "no route
+> exceeds 26 km". A first version of the enumerated fix refused three honest corrections in the replay ("across all
+> 1,024 selections, 2 fit"), so it covers "none" / "neither" only. Replaying the 1,900 recorded adversarial entries
+> changes none.
+>
+> **Where that stands.** #100 is merged with green CI (17 of 17 checks). An enumerated "all 4 routes" is still not
+> checked against a counterexample. This is still word matching; the typed claim layer the audits recommend is not
+> built. Released as 0.7.28.
+
 ## 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.27 → hypgraph-0.7.28}/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.27"
+__version__ = "0.7.28"
 
 from .bundle import anchored, verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

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

@@ -262,15 +262,19 @@ _SAYING = re.compile(r"[;:!?]|\.(?!\d)|,\s*(?=(?:and|but|while|whereas|although|
 
 
 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."""
+    """The parts of ``stmt`` that state one of ``figs`` and make the claim: 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), nor can it when the other sentence repeats the 26 (HG-027-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
+    hit = [p for p in parts if {round(v[0], 6) for v in numbers(p)} & {round(f, 6) for f in figs}]
+    # of those, the parts that make a claim ("no route is longer than 26 km"), when any does: "speed was recorded
+    # above 26" repeats the figure but claims nothing, so its words can't say what the count was of (audit HG-027-01)
+    claims = [p for p in hit if L.ABSOLUTE.search(p) or L.SUPERLATIVE.search(p)]
+    return " . ".join(_from_claim(p) for p in claims or hit) if hit else stmt
 
 
 def _from_claim(part: str) -> str:
@@ -335,7 +339,7 @@ _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(?:(?:" + 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+\$?"
+_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*|surpass\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+)?)"
@@ -353,11 +357,20 @@ def _named_figure(name: str) -> tuple[float, str] | None:
     return None
 
 
-_KEY_FIGURE = re.compile(r"\b(?:" + L.CMP_WORDS + r"|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*|surpass\w*|beat\w*)"
+                         r"(?:\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(?:" + 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_FIGURE = re.compile(r"\b(?:" + L.CMP_WORDS + r"|(?!(?:" + L.NOT_CMP + r")\b)[a-z]{3,}er)\s+than\s+\$?"
+                           r"(-?\d[\d,]*(?:\.\d+)?)|\b(?:" + L.CMP_PREPS + r"|" + L.CMP_VERBS + r")\s+\$?"
+                           r"(-?\d[\d,]*(?:\.\d+)?)|\b(?:is|are|was|were)\s+(?:over|under)\s+\$?(-?\d[\d,]*(?:\.\d+)?)",
+                           re.I)
+# "over" / "under" right after the noun "no" opens: "no route under 41 km exists" (``CMP_PREPS``)
+_CLAIM_OVER = re.compile(r"^\s*[a-z]+\s+(?:over|under)\s+\$?(-?\d[\d,]*(?:\.\d+)?)", re.I)
+# a comparison with a figure the checks can't read ("no route is longer than the usual one"): what it compares is
+# still read, so a count that compares nothing, or another way, can't back it (audit HG-027-02)
+_UNREAD_CMP = re.compile(r"\b(?:(?:" + L.CMP_WORDS + r"|(?!(?:" + L.NOT_CMP + r")\b)[a-z]{3,}er)\s+than|"
+                         + L.CMP_PREPS + r"|" + L.CMP_VERBS + r")\b", 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+(?:" + L.CMP_WORDS + r")\b", re.I)
 _SUBCLAUSE = re.compile(r",(?!\d)|[;:!?()]|\.(?!\d)|\b(?:and|but|while|whereas|although|so)\b", re.I)
@@ -395,7 +408,8 @@ def _count_figures(m: dict, rv: dict, figs: set[float] = frozenset()) -> set[flo
 # routes longer than 26 km says nothing against "the shortest is 26 km" (audit HG-022-01), and none shorter than 26
 # doesn't back "nothing is longer than 26" (HG-022-02).
 _DIRECTION_WORDS = {
-    "": {1: "more greater higher larger bigger above over exceed exceeds exceeding exceeded most highest largest "
+    "": {1: "more greater higher larger bigger above over beyond exceed exceeds exceeding exceeded surpass surpasses "
+            "surpassed surpassing most highest largest "
             "greatest biggest maximum max top",
          -1: "less fewer lower smaller below under least lowest smallest fewest minimum min"},
     "long": {1: "longer longest", -1: "shorter shortest"},
@@ -492,14 +506,18 @@ def _count_directions(m: dict, rv: dict) -> set[tuple[str, int]]:
 _ALL = re.compile(r"^(?:always|all|every|universally|invariably|consistently|without exception|100\s*%)$", re.I)
 
 
-def _clause_comparisons(clause: str) -> list[tuple[float, tuple[str, int, bool] | None]]:
+def _clause_comparisons(clause: str, after_no: bool = False) -> list[tuple[float, tuple[str, int, bool] | None]]:
     """(figure, comparison) for each comparison against a figure in a claim's clause: "longer than 26 km", "at least
-    26", "26 km or longer", "no more than 93", "above 93"; None for one that points nowhere ("beyond 93")."""
+    26", "26 km or longer", "no more than 93", "above 93", "exceeded 26"; None for one that points nowhere. With
+    ``after_no``, the clause follows "no", and "over 26" / "under 26" after its noun compare too."""
     out = []
-    for h in _CLAIM_FIGURE.finditer(clause):
+    hits = list(_CLAIM_FIGURE.finditer(clause)) + list(_CLAIM_OVER.finditer(clause) if after_no else [])
+    for h in hits:
         neg = re.search(r"\b(?:not|no)\s+$", clause[:h.start()], re.I)      # "no more than 93" is at most 93
-        num = (h.group(1) or h.group(2)).replace(",", "")
-        out += [(float(num), c) for c in _comparisons_in(clause[neg.start() if neg else h.start():h.end()]) or {None}]
+        num = next(g for g in h.groups() if g).replace(",", "")
+        said = clause[neg.start() if neg else h.start():h.end()]
+        said = said if h.re is _CLAIM_FIGURE else said[re.search(r"over|under", said, re.I).start():]
+        out += [(float(num), c) for c in _comparisons_in(said) or {None}]
     for h in _CLAIM_BOUNDARY.finditer(clause):
         num = (h.group(1) or h.group(2)).replace(",", "")
         out += [(float(num), c) for c in _comparisons_in(h.group(0)) or {None}]
@@ -510,8 +528,8 @@ def _clause_comparisons(clause: str) -> list[tuple[float, tuple[str, int, bool]
 MIXED = (frozenset(), frozenset({("mixed", 0, False)}))
 
 # "and" or "or" before a comparison with no subject of its own: "shorter than 20 km and longer than 30 km"
-_JOINED = re.compile(r"\s+(?:also\s+)?(?:(?:not|no)\s+)?(?:" + _CMP + r"\s+than\b|at\s+(?:least|most)\b|above\b|below\b|"
-                     r"beyond\b|exceed)", re.I)
+_JOINED = re.compile(r"\s+(?:also\s+)?(?:(?:not|no)\s+)?(?:" + _CMP + r"\s+than\b|at\s+(?:least|most)\b|"
+                     r"(?:" + L.CMP_PREPS + r"|" + L.CMP_VERBS + r")\b)", re.I)
 
 
 def _clause_end(stmt: str, start: int) -> int:
@@ -544,7 +562,10 @@ def _target_groups(stmt: str, w: str) -> list[list[tuple[frozenset, frozenset]]]
     for m in re.finditer(r"\b" + re.escape(w) + r"\b", stmt, re.I):
         clause = stmt[m.end():_clause_end(stmt, m.end())]
         targets = [(frozenset({fig}), frozenset() if c is None else frozenset({_negated(c) if every else c}))
-                   for fig, c in _clause_comparisons(clause)]
+                   for fig, c in _clause_comparisons(clause, after_no=w.lower() == "no")]
+        unread = _UNREAD_CMP.search(clause)
+        if not targets and unread and (comps := _comparisons_in(unread.group(0))):
+            targets = [(frozenset(), frozenset(_negated(c) if every else c for c in comps))]
         ands = any(_JOINED.match(clause, x.end()) for x in re.finditer(r"\band\b", clause, re.I))
         ors = any(_JOINED.match(clause, x.end()) for x in re.finditer(r"\bor\b", clause, re.I))
         if len(targets) > 1 and ands and ors:
@@ -767,8 +788,16 @@ def _pinned(m: dict, rv: dict, figs: set[float]) -> bool:
 
 def _absolutes(stmt: str, scope: str, body: dict, bound: list) -> list[Problem]:
     """Every absolute in the statement, and every extreme, checked on its own: a true "nothing worth more than 140
-    fits" used to end the check, and "the highest is 93" beside it went in unexamined (audit HG-021-02)."""
-    words = [w for w in L.asserted(L.ABSOLUTE, stmt) if not _enumerated(stmt, w)]
+    fits" used to end the check, and "the highest is 93" beside it went in unexamined (audit HG-021-02).
+
+    An absolute over a set the sentence enumerates ("none of the 4 routes") isn't a generalisation past the sample, so
+    it needs no count of its own; but a bound count that finds an exception still contradicts "none" or "neither"."""
+    said = L.asserted(L.ABSOLUTE, stmt)
+    enumerated = [w for w in said if _enumerated(stmt, w)]
+    words = [w for w in said if w not in enumerated]
+    # only "none" / "neither", which say nothing in the set is an exception: an enumerated "all" / "every" mostly names
+    # the set a count ran over ("across all 1,024 selections, 2 fit and are worth more"), and claims nothing of it
+    enumerated = [w for w in enumerated if w.lower() in ("none", "neither") and not _names_stated_count(stmt, w)]
     if any(str(m.get("key") or "").lower() in ("gap", "bound") for m, _rv in bound):
         words = [w for w in words if not _PROVEN.match(w)]      # an optimum with its bound (gap 0) is proven
     words = [w for w in words if not _names_counted_set(stmt, w, bound)]
@@ -797,6 +826,10 @@ def _absolutes(stmt: str, scope: str, body: dict, bound: list) -> list[Problem]:
                     "on its own can't show that something meets both. Back it with a count of either one where k is "
                     "0, or count both together", fix="count what meets both comparisons together", words=words)]]
             out += [p for g in got for p in g if p.text() not in {q.text() for q in out}]
+    for w in enumerated:
+        for figs, comps in _absolute_targets(stmt, w):
+            out += [p for p in _absolute(stmt, scope, body, bound, w, enumerated, set(figs), set(comps))
+                    if p.code == "COUNT_CONTRADICTS" and p.text() not in {q.text() for q in out}]
     if not any(p.code == "COUNT_CONTRADICTS" for p in out):
         out += _superlative_contradicted(stmt, bound)
     return out
@@ -909,7 +942,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(?:" + L.CMP_WORDS + r"|above|below|exceed\w*|beat\w*)\b", re.I)
+_BEYOND = re.compile(r"\b(?:" + L.CMP_WORDS + r"|above|below|beyond|exceed\w*|surpass\w*|beat\w*)\b", re.I)
 
 
 def _extremes(stmt: str) -> list[str]:
@@ -1392,9 +1425,19 @@ def _p_values(s: Snap, bound: list, support: list[str]) -> list[float]:
     return ps
 
 
+def _thresholds(stmt: str, comp: list[str]) -> set[str]:
+    """Comparison words that only ever compare with a figure inside an absolute: "no route exceeds 26 km" rules out
+    routes past 26, which the absolute check settles with a count; it doesn't compare two measured things."""
+    if not L.asserted(L.ABSOLUTE, stmt):
+        return set()
+    return {w for w in comp if all(re.match(r"\s+\$?\d", stmt[h.end():])
+                                   for h in re.finditer(r"\b" + re.escape(w) + r"\b", stmt, re.I))}
+
+
 def _comparisons(s: Snap, stmt: str, bound: list, support: list[str]) -> list[Problem]:
     out = []
     comp = L.asserted(L.COMPARATIVE, stmt)
+    comp = [w for w in comp if w not in _thresholds(stmt, comp)]
     tested = any(isinstance(rv.get("p"), (int, float)) or rv.get("interval") for _m, rv in bound)
     if comp and len([1 for _m, rv in bound if _primary(rv) is not None]) < 2 and not tested \
             and not _measured_claim(s, support):

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

@@ -19,6 +19,11 @@ CMP_WORDS = ("longer|shorter|more|less|fewer|greater|higher|lower|larger|smaller
              "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"
+# the words other than "-er than" that compare with a figure, in every tense ("no route exceeded 26 km" is the same
+# claim as "no route exceeds 26 km": audit HG-027-02). "over" and "under" are apart: "over 1,024 selections" is how
+# many were counted, not a bound, so they compare only after "is" / "was" or a noun that "no" opens.
+CMP_PREPS = "above|below|beyond"
+CMP_VERBS = "exceed(?:s|ed|ing)?|surpass(?:es|ed|ing)?"
 
 ABSOLUTE = re.compile(
     r"\b(never|always|all|every|none|nothing|no one|nobody|impossible|cannot|can't|proves?|proven|proof|certainly|"
@@ -31,8 +36,8 @@ ABSOLUTE = re.compile(
     # 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)
+    r"\$?\d[\d,.]*(?:\s+[a-z%]+){0,2}\s+or\s+(?:" + CMP_WORDS + r")\b|(?:" + CMP_WORDS + r"|" + CMP_PREPS + r"|over|"
+    r"under|" + CMP_VERBS + r")\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|"

hypgraph-0.7.28/tests/test_figure_said_twice.py

@@ -0,0 +1,121 @@
+"""A figure said twice, a comparison in another tense (audit of 0.7.27, HG-027-01 and -02).
+
+What a count must be about is said in the clause that makes the claim. "Speed was recorded above 26 separately; no
+route is longer than 26 km" repeats the 26, but the first clause claims nothing, so its "speed" can't make a speed count
+named "routes longer than 26 km" back the length claim. "No route exceeded 26 km" is the same claim as "no route exceeds
+26 km": every tense, and "surpassed", "went beyond", "was over", reads its figure, so the counterexample counted at 26
+contradicts it and a count that compares nothing can't back it. Invariants: an extra clause never turns a refusal into
+an acceptance, with the figure repeated or not; a comparison read in one tense is read in all; an honest count backs its
+claim in every wording."""
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+
+SCOPE = "The surveyed items, against the stated mark."
+
+
+def outcome(values, statement, meas=(), scope=SCOPE):
+    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=4):
+    return {"k": k, "n": n, "figure": figure, "op": op}
+
+
+def M(key, name, k, n=4):
+    return {"name": name, "key": key, "k": k, "n": n}
+
+
+# (frozen values, the relabelled count, the claim with the figure repeated in a clause that claims nothing)
+REPEATED = {
+    "speed as length": ({"route_speed_above_26": t(0, 26)}, M("route_speed_above_26", "routes longer than 26 km", 0),
+                        ["Speed was recorded above 26 separately; no route is longer than 26 km among the 4 routes.",
+                         "No route is longer than 26 km among the 4 routes; speed was independently recorded above "
+                         "26."]),
+    "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),
+                           ["Cargo routes were checked against 26 km; no passenger route is longer than 26 km among "
+                            "the 4 routes."]),
+    "depth as temperature": ({"well_depth_above_30": t(0, 30)}, M("well_depth_above_30", "wells warmer than 30 C", 0),
+                             ["Depth was logged down to 30 m; no well is warmer than 30 C among the 4 wells.",
+                              "No well is warmer than 30 C among the 4 wells, and depth was logged past 30 too."]),
+    "rural as urban": ({"rural_clinic_waits_above_45": t(0, 45), "urban_clinic_waits_above_45": t(2, 45)},
+                       M("rural_clinic_waits_above_45", "urban clinic waits above 45 minutes", 0),
+                       ["Rural clinics kept waits under 45 minutes; no urban clinic had waits above 45 minutes among "
+                        "the 4 clinics."]),
+    "age as length": ({"bridge_age_above_60": t(0, 60)}, M("bridge_age_above_60", "bridges longer than 60 m", 0),
+                      ["Ages above 60 were noted in the register; no bridge is longer than 60 m among the 4 bridges."]),
+}
+
+
+@pytest.mark.parametrize("case", list(REPEATED))
+def test_a_figure_repeated_elsewhere_does_not_lend_its_clause_words(case):
+    """HG-027-01: every clause that said the count's figure was read for what the count was of."""
+    values, m, statements = REPEATED[case]
+    for s in statements:
+        assert "MEASUREMENT_MISMATCH" in outcome(values, s, [m]), s
+
+
+TENSES = ["No route exceeded 26 km among the 4 routes.", "No route has exceeded 26 km among the 4 routes.",
+          "No route surpassed 26 km among the 4 routes.", "No route went beyond 26 km among the 4 routes.",
+          "No route was over 26 km among the 4 routes.", "No route exceeds 26 km among the 4 routes.",
+          "None of the 4 routes exceeded 26 km.", "Nothing exceeded 26 km among the 4 routes."]
+PROCESSED = M("routes_processed", "routes processed", 4)
+
+
+@pytest.mark.parametrize("s", TENSES)
+def test_every_tense_finds_the_counterexample(s):
+    """HG-027-02: "exceeded" made the claim an absolute but its figure went unread, so a complete count of something
+    else backed it over the counterexample bound beside it."""
+    values = {"routes_processed": {"k": 4, "n": 4}, "routes_above_26": t(1, 26)}
+    assert "COUNT_CONTRADICTS" in outcome(values, s, [PROCESSED, M("routes_above_26", "routes above 26 km", 1)])
+
+
+@pytest.mark.parametrize("s", [x for x in TENSES if not x.startswith("None")])
+def test_a_count_that_compares_nothing_backs_no_tense(s):
+    assert "ABSOLUTE_WITHOUT_COUNT" in outcome({"routes_processed": {"k": 4, "n": 4}}, s, [PROCESSED])
+
+
+def test_a_comparison_whose_figure_cannot_be_read_is_not_backed_by_a_count_of_something_else():
+    s = "No route is longer than the usual one among the 4 routes."
+    assert "ABSOLUTE_WITHOUT_COUNT" in outcome({"routes_processed": {"k": 4, "n": 4}}, s, [PROCESSED])
+
+
+@pytest.mark.parametrize("s", [*TENSES, "Speeds above 26 were logged too; no route exceeded 26 km among the 4 routes."])
+def test_an_honest_count_backs_every_tense(s):
+    """One count is enough: "exceeds 26 km" inside "no route …" is a bound the count settles, not two things compared."""
+    assert outcome({"routes_above_26": t(0, 26)}, s, [M("routes_above_26", "routes above 26 km", 0)]) == []
+
+
+@pytest.mark.parametrize("s", ["No route under 20 km exists among the 4 routes.",
+                               "No route is under 20 km among the 4 routes."])
+def test_under_after_no_is_a_bound(s):
+    m = M("routes_under_20", "routes under 20 km", 0)
+    assert outcome({"routes_under_20": t(0, 20, "<")}, s, [m]) == []
+    assert "COUNT_CONTRADICTS" in outcome({"routes_under_20": t(1, 20, "<")}, s, [{**m, "k": 1}])
+
+
+def test_over_a_number_of_runs_is_not_a_bound():
+    """"over 1000 runs" says how many were run."""
+    assert outcome({"checker_failures": {"k": 0, "n": 1000}}, "The checker never failed over 1000 runs.",
+                   [M("checker_failures", "checker failures", 0, 1000)], scope="1000 runs of the checker.") == []
+
+
+def test_an_enumerated_none_is_still_contradicted_by_its_count():
+    """"none of the 4 routes" needs no count of its own, but one that finds an exception still says it's false."""
+    s = "None of the 4 routes is longer than 26 km."
+    assert outcome({"routes_above_26": t(0, 26)}, s, [M("routes_above_26", "routes above 26 km", 0)]) == []
+    assert "COUNT_CONTRADICTS" in outcome({"routes_above_26": t(1, 26)}, s,
+                                          [M("routes_above_26", "routes above 26 km", 1)])