hypgraph 0.7.26__tar.gz → 0.7.28__tar.gz

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

@@ -1,5 +1,53 @@
 # 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
+(`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.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.7.26
+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.26 → 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.26 (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.26 → hypgraph-0.7.28}/docs/RELEASE-READINESS.md

@@ -181,6 +181,38 @@ 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.
+
+> **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.26 → 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.26"
+__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.26 → hypgraph-0.7.28}/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,36 @@ 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`` 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 = [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:
+    """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 +339,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*|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+)?)"
-                                    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 +357,22 @@ 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*|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(?: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|"
-                           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+(?: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)
 
 
@@ -374,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"},
@@ -382,6 +417,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 +432,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 +450,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]]:
@@ -458,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}]
@@ -476,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:
@@ -510,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:
@@ -582,12 +637,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 +682,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 +692,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]:
@@ -719,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)]
@@ -733,9 +810,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
@@ -748,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
@@ -860,8 +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(?: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|beyond|exceed\w*|surpass\w*|beat\w*)\b", re.I)
 
 
 def _extremes(stmt: str) -> list[str]:
@@ -1344,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.26 → hypgraph-0.7.28}/src/hypgraph/language.py

@@ -14,6 +14,17 @@ 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"
+# 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|"
     r"certain|guaranteed?|guarantees|eliminat(?:es|ed|ing)|entirely|completely|totally|universally|invariably|"
@@ -22,14 +33,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"|" + 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|"
-    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.28/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