hypgraph 0.7.22__tar.gz → 0.7.23__tar.gz

{hypgraph-0.7.22 → hypgraph-0.7.23}/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## 0.7.23 — 2026-11-01: a count points one way, "no route is longer", what a unit is said of
+
+Fixes from an independent audit of 0.7.22 (HG-022-01 to -05); each case below failed on 0.7.22 and is now a test.
+
+- **A count points one way** (HG-022-01, -02). A count of routes longer than 26 km matched "the shortest route is
+  26 km" on the figure, so the true claim was refused as `COUNT_CONTRADICTS`; and a count of none shorter than 26
+  backed "nothing is longer than 26 km". Comparisons now carry a direction on an axis ("longer" / "shorter",
+  "faster" / "slower"; "more", "above", "highest" meet any axis), and a count that points the other way from the
+  claim's exceptions neither refutes nor backs it. A result can state the comparison with the count
+  (`{"k": 2, "n": 3, "figure": 26, "op": ">"}`); that is the only direction, and a measurement whose name points the
+  other way is refused as `MEASUREMENT_MISMATCH`. Without one, a name and key that point opposite ways can widen what
+  a count refutes, never what it backs.
+- **"No route is longer than 26 km" is an absolute** (HG-022-02), like "nothing is longer": it needs a count of
+  exceptions. Only a "no" that opens its clause, followed within three words by a copula and a comparison, is read
+  this way ("routes that visit no town twice" is not one).
+- **A unit of record said with a verb** (HG-022-03). Only "is / are / was / were" stated a unit, so "recorded parcel
+  weights use pounds" went in beside the note that every recorded parcel weight is in kilograms. A short, fixed list
+  is read too: use, recorded / measured / expressed / given / listed / reported / denominated / kept / stated /
+  written / logged / entered / priced / quoted in. A hedge ("might be recorded in pounds") asserts nothing.
+- **Two things that share a word are two things** (HG-022-04). "Passenger weights are recorded in pounds" was refused
+  against a source saying shipping weights are in kilograms, on the word "weights". A unit is now compared only when
+  the two subjects have the same head and don't each carry modifiers the other lacks entirely; every clause of the
+  source is read, and one that says the claim's unit of that thing means no contradiction.
+- **A quantity is not a unit of record** (HG-022-05). "The parcel mass is about 2.2 pounds", citing "the parcel mass
+  is one kilogram", was refused: a unit after a number ("2.2 pounds", "one kilogram", "36 kg") is a quantity, and
+  isn't compared. The refusal no longer says a quantity can't be in two units; it says the source doesn't support the
+  statement.
+- Limits: which thing a subject names and which unit a record uses are read from words, not typed; conversions
+  aren't checked, so "2.2 pounds" against "50 kilograms" goes in; verbs outside the list aren't read; the "no X is
+  longer" pattern is narrow ("there is no route longer" isn't read); and a direction is read only from the comparison
+  words above.
+
 ## 0.7.22 — 2026-11-01: a label can't move a count, every part of a claim is checked, units rule each other out
 
 Fixes from an independent audit of 0.7.21 (HG-021-01 to -04); each case below failed on 0.7.21 and is now a test.

{hypgraph-0.7.22 → hypgraph-0.7.23}/PKG-INFO

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

@@ -114,6 +114,23 @@ was taken from a changelog without being checked against the code.*
 > suite is 482 passed, and hypswarm (118 passed) and hypmesh (37 passed) pass on it. The audit asks for a fresh
 > independent audit before anyone claims 0.7.22 resists these attack classes. Released as 0.7.22.
 
+> **Audit of 0.7.22 (2026-11-01), fixed for 0.7.23.** A third independent audit found five cases, each reproduced on
+> the 0.7.22 wheel. Two let a count stand for its opposite: a count of routes longer than 26 km refused the true "the
+> shortest route is 26 km" (HG-022-01), and none shorter than 26 backed "nothing / no route is longer than 26 km"
+> (HG-022-02). One let a unit claim in: "recorded parcel weights use pounds" stated no copula (HG-022-03). Two made
+> false accusations: "passenger weights" was matched with "shipping weights" on a shared word (HG-022-04), and a
+> quantity converted to another unit was read as a unit of record (HG-022-05). Comparisons now carry a direction, and
+> a result can state its comparison (`op`); "no X is longer than…" opening a clause is an absolute; a short fixed list
+> of verbs states a unit; units are compared only between subjects with the same head and compatible modifiers; a unit
+> after a number is a quantity. Each case is a regression test written to fail on 0.7.22. Replaying the 1,900
+> recorded adversarial entries names exactly the same parties as 0.7.22; one repeated false unit claim is no longer
+> refused, because 0.7.22 had refused it on a shared word and a quantity, and its author is still named.
+>
+> **Where that stands.** #87 is merged with green CI (17 of 17 checks); from the 0.7.23 wheel in a fresh venv the
+> suite is 504 passed, and hypswarm (118 passed) and hypmesh (37 passed) pass on it. Which thing a subject names and
+> which unit a record uses are still read from words, not typed; a fresh independent audit should precede any claim
+> that 0.7.23 resists these attack classes. Released as 0.7.23.
+
 ## 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.22 → hypgraph-0.7.23}/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.22"
+__version__ = "0.7.23"
 
 from .bundle import anchored, verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.7.22 → hypgraph-0.7.23}/src/hypgraph/checks.py

@@ -213,6 +213,12 @@ def _bound(s: Snap, meas: list) -> tuple[list[tuple[dict, dict]], list[Problem]]
                                     f"{said.group(0).strip()}, but result {m['result']} counted '{m['key']}' against "
                                     f"{_fmt(f)}", fix=f"name the count after {_fmt(f)}, the figure it was made against"))
             bad = True
+        op, named = stated_op(rv), _directions(str(m.get("name") or ""))
+        if not bad and op and any(_opposed(d, ("", _OPS[op])) for d in named):
+            problems.append(Problem("MEASUREMENT_MISMATCH", f"measurement {m.get('name')}: its name points the other "
+                                    f"way from what result {m['result']} counted for '{m['key']}' ({op})",
+                                    fix=f"name the count after the comparison it made ({op})"))
+            bad = True
         if not bad:
             good.append((m, rv))
     return good, problems
@@ -301,6 +307,74 @@ def _count_figures(m: dict, rv: dict, figs: set[float] = frozenset()) -> set[flo
     return out
 
 
+# which way a comparison points, as (axis, sign): "longer" and "longest" point up the length axis, "shorter" and
+# "shortest" down it; "more", "above", "highest" point up with no axis of their own, so they meet any axis. A count of
+# 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 "
+            "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"},
+    "good": {1: "better best", -1: "worse worst"},
+    "fast": {1: "faster fastest", -1: "slower slowest"},
+    "cost": {1: "dearer dearest", -1: "cheaper cheapest"},
+    "time": {1: "later latest", -1: "earlier earliest"},
+}
+_DIRECTION_OF = {w: (axis, sign) for axis, signs in _DIRECTION_WORDS.items() for sign, ws in signs.items()
+                 for w in ws.split()}
+_OPS = {">": 1, ">=": 1, "<": -1, "<=": -1}
+
+
+def _directions(text: str) -> set[tuple[str, int]]:
+    return {_DIRECTION_OF[w] for w in re.findall(r"[a-z]+", (text or "").lower()) if w in _DIRECTION_OF}
+
+
+def _opposed(a: tuple[str, int], b: tuple[str, int]) -> bool:
+    """Do these point opposite ways on one axis? An axis-free word ("more") meets any axis; two different axes
+    ("longer", "faster") can't be compared, so they aren't opposed."""
+    return a[1] != b[1] and (a[0] == b[0] or not a[0] or not b[0])
+
+
+def stated_op(rv: dict) -> str | None:
+    """The comparison a count says it made, written by the instrument beside it: {"k": 2, "n": 3, "figure": 26,
+    "op": ">"} is two found above 26."""
+    op = rv.get("op")
+    return op if op in _OPS else None
+
+
+def _count_directions(m: dict, rv: dict) -> set[tuple[str, int]]:
+    """Every way a bound count could point; empty when nothing says. A comparison the result states is the only one.
+    Otherwise its name's and its key's: as with its figure, the author writes the name, so a name that points the
+    other way from the key adds a direction and never replaces one."""
+    op = stated_op(rv)
+    if op:
+        return {("", _OPS[op])}
+    return _directions(str(m.get("name") or "")) | _directions(str(m.get("key") or "").replace("_", " "))
+
+
+def _claim_directions(stmt: str, w: str = "") -> set[tuple[str, int]]:
+    """Which way the exceptions to a claim point: those the absolute ``w``'s own clause compares against ("nothing
+    longer than 26 km" — longer), else those beyond its extremes ("the shortest route is 26 km" — shorter)."""
+    out: set[tuple[str, int]] = set()
+    for m in re.finditer(r"\b" + re.escape(w) + r"\b", stmt, re.I) if w else ():
+        end = next((x.start() for x in _SUBCLAUSE.finditer(stmt, m.end())), len(stmt))
+        out |= {d for h in _CLAIM_FIGURE.finditer(stmt[m.end():end]) for d in _directions(h.group(0))}
+    return out or {d for x in _extremes(stmt) for d in _directions(x)}
+
+
+def _points(m: dict, rv: dict, a: tuple[int, int], dirs: set[tuple[str, int]]) -> bool:
+    """Does this count point the way the claim's exceptions do? One that points the other way can't refute the claim
+    or back it. When it could point either way (a name against its key), a count that finds some may still refute,
+    and a count of none or all backs the claim only if no way it could point is the other way. A count, or a claim,
+    whose direction can't be told is read as before."""
+    c = _count_directions(m, rv)
+    if not c or not dirs:
+        return True
+    against = {d for d in c if all(_opposed(d, x) for x in dirs)}
+    return against != c if 0 < a[0] < a[1] else not against
+
+
 def _absolute_figures(stmt: str, w: str) -> set[float]:
     """The figures an absolute is about: one its own clause compares against ("nothing worth more than 93 fits"),
     else the figures the statement's extremes name ("the highest is 93; nothing worth more fits")."""
@@ -311,12 +385,15 @@ def _absolute_figures(stmt: str, w: str) -> set[float]:
     return figs or _extreme_figures(stmt)
 
 
-def _bears(m: dict, rv: dict, a: tuple[int, int], figs: set[float]) -> bool:
+def _bears(m: dict, rv: dict, a: tuple[int, int], figs: set[float],
+           dirs: set[tuple[str, int]] = frozenset()) -> bool:
     """Does this count bear on a claim about ``figs``? One about another figure doesn't, whatever it finds: a zero
     beyond 140 can't vouch for 93, and two beyond 93 can't refute 95. When it could be about more than one figure (a
     name that disagrees with its key), a count that finds some bears if any of them is the claim's, and a count of
     none or all only if every one is: a label can widen what a count refutes, never what it vouches for. A count that
     names no figure, or a claim that names none, is read as before."""
+    if not _points(m, rv, a, dirs):
+        return False
     c = _count_figures(m, rv, figs)
     if not c or not figs:
         return True
@@ -349,7 +426,8 @@ def _absolutes(stmt: str, scope: str, body: dict, bound: list) -> list[Problem]:
 
 
 def _absolute(stmt: str, scope: str, body: dict, bound: list, w: str, words: list, figs: set[float]) -> list[Problem]:
-    arms = [(m, rv, a) for m, rv in bound if (a := _arm(rv)) and _bears(m, rv, a, figs)]
+    dirs = _claim_directions(stmt, w)
+    arms = [(m, rv, a) for m, rv in bound if (a := _arm(rv)) and _bears(m, rv, a, figs, dirs)]
     about = L.content_words(stmt)
     # a count at the claim's own figure that finds exceptions refutes it, whatever else is bound beside it
     pinned = [(m, a) for m, rv, a in arms if _pinned(m, rv, a, figs)
@@ -506,7 +584,8 @@ def _superlative_contradicted(stmt: str, bound: list) -> list[Problem]:
         return []
     about = L.content_words(stmt)
     figs = _extreme_figures(stmt)
-    rel = [(m, rv, a) for m, rv in bound if (a := _arm(rv)) and _bears(m, rv, a, figs)
+    dirs = _claim_directions(stmt)
+    rel = [(m, rv, a) for m, rv in bound if (a := _arm(rv)) and _bears(m, rv, a, figs, dirs)
            and (L.content_words(f"{m.get('name', '')} {m.get('key', '')}") & about
                 or _BEYOND.search(f"{m.get('name', '')} {m.get('key', '')}".replace("_", " "))
                 or stated_figure(rv) in figs)]
@@ -720,22 +799,60 @@ def _plural(canon: str) -> str:
             "yen": "yen", "yuan": "yuan"}.get(canon, canon + "s")
 
 
-def _units_in(text: str) -> set[tuple[str, str]]:
-    return {u for w in re.findall(r"[a-z]+", (text or "").lower()) for u in _UNIT_OF.get(w, ())}
+# a unit after a number is a quantity ("about 2.2 pounds", "one kilogram", "36 kg"), not the unit something is
+# recorded in: a quantity converted into another unit says nothing against a source's unit (audit HG-022-05)
+_QUANTITY = re.compile(r"(?:\d|\b(?:a|an|one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|twenty|thirty|"
+                       r"forty|fifty|hundred|hundreds|thousand|thousands|million|millions|dozen|dozens|half|quarter|"
+                       r"few|several|couple)\b)[\s-]*(?:of\s+)?$", re.I)
 
 
-_CONDITIONAL = re.compile(r"\b(?:if|whether|unless|suppos\w*|assum\w*|were they|had they)\b", re.I)
+def _units_in(text: str) -> set[tuple[str, str]]:
+    """The units of record ``text`` names: a unit a number comes before is a quantity and doesn't count."""
+    text = (text or "").lower()
+    return {u for m in re.finditer(r"[a-z]+", text) if m.group(0) in _UNIT_OF
+            and not _QUANTITY.search(text[:m.start()]) for u in _UNIT_OF[m.group(0)]}
 
 
-def _unit_assertions(text: str) -> list[tuple[set[str], set[tuple[str, str]], str]]:
-    """(subject words, units asserted of it, clause) for each clause with a copula, outside the reach of negation:
-    "the recorded weights are in pounds" says pounds of the recorded weights. A condition ("if the weights are
-    pounds") asserts nothing."""
+_CONDITIONAL = re.compile(r"\b(?:if|whether|unless|suppos\w*|assum\w*|were they|had they)\b", re.I)
+# what states the unit something is in: a copula, or one of a short, fixed list of verbs ("recorded parcel weights use
+# pounds", "the weights are given in pounds"; audit HG-022-03). Prose outside the list isn't read.
+_RECORDS = re.compile(r"\b(?:is|are|was|were|uses?|used|using|(?:recorded|measured|expressed|given|listed|reported|"
+                      r"denominated|kept|stated|written|logged|entered|priced|quoted)\s+(?:in|as|using))\b", re.I)
+_HEDGED = re.compile(r"\b(?:may|might|could|perhaps|possibly)\b", re.I)
+_DETERMINERS = set("a an the all every each any some these those this that its their our his her both".split())
+_PREPOSITIONS = set("of in for from on at by with to among across within under over into per".split())
+
+
+def _subject(text: str) -> tuple[str, frozenset[str]]:
+    """What a unit is said of, as (head, modifiers): "every recorded parcel weight in the register" is (weight,
+    {recorded, parcel}). Determiners go, and the subject ends at its first preposition."""
+    words = []
+    for w in re.findall(r"[a-z]+", (text or "").lower()):
+        if w in _PREPOSITIONS and words:
+            break
+        if w not in _DETERMINERS:
+            words += sorted(L.content_words(w))
+    return (words[-1], frozenset(words[:-1])) if words else ("", frozenset())
+
+
+def _same_thing(a: tuple[str, frozenset[str]], b: tuple[str, frozenset[str]]) -> bool:
+    """Could these be one thing? Their heads must match, and two subjects each named for something the other isn't
+    ("passenger weights", "shipping weights") are two things (audit HG-022-04). A bare "weights" may be either."""
+    return bool(a[0]) and a[0] == b[0] and (not a[1] or not b[1] or bool(a[1] & b[1]))
+
+
+def _unit_assertions(text: str) -> list[tuple[tuple[str, frozenset[str]], set[tuple[str, str]], str]]:
+    """(subject, units of record asserted of it, clause) for each clause that states one, outside the reach of
+    negation: "the recorded weights are in pounds" says pounds of the recorded weights. A condition ("if the weights
+    are pounds") or a hedge ("the weights might be recorded in pounds") asserts nothing."""
     out = []
     for c in _UNIT_CLAUSE.split(_unnegated(text or "")):
-        cop = _ASSERTS.search(c)
-        if cop and not _CONDITIONAL.search(c[:cop.start()]) and (units := _units_in(c[cop.end():])):
-            out.append((L.content_words(c[:cop.start()]), units, c.strip()))
+        verb = _RECORDS.search(c)
+        if not verb or _CONDITIONAL.search(c[:verb.start()]) or _HEDGED.search(c[:verb.start()]):
+            continue
+        subj = _subject(c[:verb.start()])
+        if subj[0] and (units := _units_in(c[verb.end():])):
+            out.append((subj, units, c.strip()))
     return out
 
 
@@ -746,25 +863,23 @@ def asserted_units(stmt: str) -> set[str]:
 
 
 def _other_unit(passage: str, stmt: str) -> tuple[str, str, str] | None:
-    """(the statement's unit, the source's, the source sentence) when a sentence of ``passage`` says the statement's
-    subject is in another unit of the same kind, and no clause of the statement about that subject says the source's
-    unit too (a clause that only converts, "about 2.2 pounds each", asserts nothing; "kilograms, not pounds" is a
-    denial, checked above)."""
+    """(the statement's unit, the source's, the source sentence) when the source says the statement's subject is in
+    another unit of the same kind, nowhere says it is in the statement's, and no clause of the statement about that
+    subject says the source's unit too ("kilograms, not pounds" is a denial, checked above)."""
     claimed = _unit_assertions(stmt)
     if not claimed:
         return None
-    for sent in re.split(r"(?<=[.!?;])\s+", passage or ""):
-        clean = _unnegated(sent)
-        cop = list(_ASSERTS.finditer(clean))
-        if not cop:
-            continue
-        subj, said = L.content_words(clean[:cop[-1].start()]), _units_in(clean[cop[-1].end():])
-        about = [units for csubj, units, _c in claimed if csubj & subj]
-        also = {u for units in about for u in units}
-        for fam, canon in sorted(also):
+    given = [(subj, units, sent.strip()) for sent in re.split(r"(?<=[.!?;])\s+", passage or "")
+             for subj, units, _c in _unit_assertions(sent)]
+    for csubj, cunits, _c in claimed:
+        theirs_all = [(units, sent) for subj, units, sent in given if _same_thing(csubj, subj)]
+        said = {u for units, _s in theirs_all for u in units}
+        also = {u for subj, units, _c in claimed if _same_thing(csubj, subj) for u in units}
+        for fam, canon in sorted(cunits):
             theirs = {c for f, c in said if f == fam}
             if theirs and canon not in theirs and not {(fam, c) for c in theirs} & also:
-                return canon, sorted(theirs)[0], sent.strip()
+                sent = next(s for units, s in theirs_all if any(f == fam for f, _c in units))
+                return canon, sorted(theirs)[0], sent
     return None
 
 
@@ -805,8 +920,8 @@ def _source_contradicts(s: Snap, stmt: str, support: list[str]) -> list[Problem]
             label = cite[:80] if cite else (n.get("code") or src)
             return [Problem("SOURCE_CONTRADICTS",
                             f"the statement says {_plural(ours)}, but a source it links as support ({label}) says "
-                            f"{_plural(theirs)}: \"{sent[:200]}\". One quantity isn't in two units of one kind, so that source isn't "
-                            "support: correct the statement, or link the source as a challenge",
+                            f"{_plural(theirs)} for the same thing: \"{sent[:200]}\". That source doesn't support the statement: "
+                            "correct the statement, or link the source as a challenge",
                             fix="correct the statement, or link that source as a challenge", words=[f"unit:{ours}"])]
     return []
 

{hypgraph-0.7.22 → hypgraph-0.7.23}/src/hypgraph/language.py

@@ -18,7 +18,11 @@ 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|"
     r"consistently|without exception|perfect(?:ly)?|solves?|solved|definitively|conclusively|undeniably|"
-    r"zero(?!-))\b|(?<![\d.])100\s*%", re.I)
+    r"zero(?!-)"
+    # "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)
+    r"|(?<![a-z] )no(?=\s+(?:[a-z]+\s+){1,3}?(?:is|are|was|were)\s+(?:any\s+)?(?:longer|shorter|more|less|fewer|greater|higher|"
+    r"lower|larger|smaller|better|worse|faster|slower|cheaper|above|below|over|under)\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.23/tests/test_direction_and_units.py

@@ -0,0 +1,167 @@
+"""Which way a count points, and what a unit says (audit of 0.7.22, HG-022-01..05).
+
+A count of routes longer than 26 km says nothing against "the shortest route is 26 km", and a count of none shorter
+than 26 doesn't back "nothing is longer than 26". A source's unit of record is compared only with the same thing's
+unit of record: not with another thing that shares a word, and not with a quantity converted into another unit."""
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+
+ROUTES = "The three surveyed routes, of 26, 31 and 35 km."
+
+
+def record(values):
+    g = Graph(policy=Policy(reviewers={"critic"}))
+    inv = g.author("curator").investigation("Routes", "Which surveyed route is shortest?")["id"]
+    lab = g.author("lab")
+    run = lab.add("run", inv, kind="lab", state="succeeded", name="Measured the surveyed routes.")
+    r = lab.add("result", inv, kind="computed", outcome="positive", summary="Route counts against 26 km.",
+                values=values, links=[{"rel": "produced", "from": run["id"]}])["id"]
+    return g, inv, r
+
+
+def source(g, inv, passage):
+    return g.author("curator").add("source", inv, citation="Records note", passage=passage, kind="primary")["id"]
+
+
+def write(g, inv, statement, links, meas=(), scope=ROUTES, who="a"):
+    return g.author(who).add("claim", inv, statement=statement, scope=scope, measurements=list(meas),
+                             links=[{"rel": "supports", "from": x, "why": "Cited for the claim."} for x in links])
+
+
+def codes(e) -> list[str]:
+    return [p["code"] for p in e.value.problems]
+
+
+def count(r, key, name, k, n=3):
+    return {"name": name, "result": r, "key": key, "k": k, "n": n}
+
+
+SHORTEST = {"name": "shortest route km", "key": "shortest_km", "value": 26}
+
+
+@pytest.mark.parametrize("typed", [{}, {"figure": 26}, {"figure": 26, "op": ">"}])
+def test_a_count_the_other_way_does_not_refute_a_true_extreme(typed):
+    """HG-022-01: the true "the shortest route is 26 km", with 2 of 3 routes longer than 26 bound, was refused as
+    COUNT_CONTRADICTS: the count matched the figure, and nothing asked which way it pointed."""
+    g, inv, r = record({"longer_than_26": {"k": 2, "n": 3, **typed}, "shortest_km": 26})
+    write(g, inv, "The shortest route is 26 km.", [r],
+          [count(r, "longer_than_26", "routes longer than 26 km", 2), {**SHORTEST, "result": r}])
+    assert "a" not in g.conduct(inv)
+    # the count the claim needs still decides: 1 of 3 shorter than 31 refutes "the shortest is 31"
+    g, inv, r = record({"shorter_than_31": {"k": 1, "n": 3, **({"figure": 31} if typed else {})}, "x_km": 31})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "The shortest route is 31 km.", [r],
+              [count(r, "shorter_than_31", "routes shorter than 31 km", 1),
+               {"name": "route km", "result": r, "key": "x_km", "value": 31}])
+    assert "COUNT_CONTRADICTS" in codes(e)
+
+
+@pytest.mark.parametrize("typed", [{}, {"figure": 26}, {"figure": 26, "op": "<"}])
+@pytest.mark.parametrize("statement", ["Nothing is longer than 26 km among the 3 routes.",
+                                       "No route is longer than 26 km among the 3 routes."])
+def test_a_count_the_other_way_does_not_back_an_absolute(typed, statement):
+    """HG-022-02: none of 3 routes shorter than 26 backed "nothing is longer than 26 km among the 3 routes". It is
+    the wrong count: the claim goes in only with a count of routes longer than 26, which here finds 2."""
+    g, inv, r = record({"shorter_than_26": {"k": 0, "n": 3, **typed}, "longer_than_26": {"k": 2, "n": 3}})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, statement, [r], [count(r, "shorter_than_26", "routes shorter than 26 km", 0)])
+    assert "ABSOLUTE_WITHOUT_COUNT" in codes(e) and "COUNT_CONTRADICTS" not in codes(e)
+    with pytest.raises(GraphError) as e:
+        write(g, inv, statement, [r], [count(r, "shorter_than_26", "routes shorter than 26 km", 0),
+                                       count(r, "longer_than_26", "routes longer than 26 km", 2)])
+    assert "COUNT_CONTRADICTS" in codes(e)
+    # the true absolute with its own count goes in
+    write(g, inv, "No route is shorter than 26 km among the 3 routes.", [r],
+          [count(r, "shorter_than_26", "routes shorter than 26 km", 0)])
+
+
+def test_a_no_inside_a_phrase_is_not_an_absolute():
+    """"no route is longer" opens its clause with "no"; "routes that visit no town twice" only describes them. A true
+    count sentence with that phrase in it goes in."""
+    g, inv, r = record({"shorter_than_31": {"k": 1, "n": 3}})
+    write(g, inv, "One of the 3 routes that visit no town twice is shorter than 31 km.", [r],
+          [count(r, "shorter_than_31", "routes shorter than 31 km", 1)])
+    assert "a" not in g.conduct(inv)
+
+
+def test_a_stated_direction_decides_and_a_label_cannot_flip_it():
+    """A result can state which way its count points ({"op": "<"}); a measurement whose name points the other way is
+    refused. Without one, a name and key that point opposite ways can widen what the count refutes, never what it
+    backs."""
+    g, inv, r = record({"shorter_than_26": {"k": 0, "n": 3, "figure": 26, "op": "<"},
+                        "beyond_26": {"k": 0, "n": 3}})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "Nothing is longer than 26 km among the 3 routes.", [r],
+              [count(r, "shorter_than_26", "routes longer than 26 km", 0)])
+    assert "MEASUREMENT_MISMATCH" in codes(e) and "<" in str(e.value)
+    # untyped: the name says longer, the key says shorter: a zero can't back "nothing longer"
+    g, inv, r = record({"shorter_than_26": {"k": 0, "n": 3}})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "Nothing is longer than 26 km among the 3 routes.", [r],
+              [count(r, "shorter_than_26", "routes longer than 26 km", 0)])
+    assert "ABSOLUTE_WITHOUT_COUNT" in codes(e)
+
+
+def test_the_direction_of_words():
+    from hypgraph.checks import _claim_directions, _count_directions, _opposed
+    d = lambda name, key="x", rv=None: _count_directions({"name": name, "key": key}, rv or {})   # noqa: E731
+    assert d("routes longer than 26 km") == {("long", 1)}
+    assert d("routes shorter than 26 km") == {("long", -1)}
+    assert d("fitting selections worth more than 93") == {("", 1)}
+    assert d("fitting selections worth exactly 93") == set()
+    assert d("x", rv={"op": "<="}) == {("", -1)}
+    assert d("routes longer than 26 km", "shorter_than_26") == {("long", 1), ("long", -1)}
+    assert _claim_directions("The shortest route is 26 km.") == {("long", -1)}
+    assert _claim_directions("The highest total value that fits is 93.") == {("", 1)}
+    assert _claim_directions("Nothing worth more than 93 fits.", "Nothing") == {("", 1)}
+    assert _opposed(("long", 1), ("long", -1)) and _opposed(("", 1), ("long", -1))
+    assert not _opposed(("long", 1), ("fast", -1)) and not _opposed(("", 1), ("", 1))
+
+
+UNITS = "Every recorded parcel weight is in kilograms, not pounds."
+
+
+@pytest.mark.parametrize("statement", ["Recorded parcel weights use pounds.",
+                                       "The recorded parcel weights are given in pounds.",
+                                       "Recorded parcel weights were logged in pounds.",
+                                       "The recorded parcel weights are expressed in pounds."])
+def test_a_unit_of_record_said_without_a_copula(statement):
+    """HG-022-03: only "is / are / was / were" said a unit, so "recorded parcel weights use pounds" went in beside
+    the kilograms note. A short, fixed list of verbs that state a unit of record is read too."""
+    g, inv, _r = record({"x": {"k": 0, "n": 3}})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, statement, [source(g, inv, UNITS)], scope="The parcel register.")
+    assert "SOURCE_CONTRADICTS" in codes(e)
+
+
+@pytest.mark.parametrize("passage", [
+    "Shipping weights are recorded in kilograms; passenger weights are recorded in pounds.",
+    "Passenger weights are recorded in pounds; shipping weights are recorded in kilograms.",
+    "Shipping weights are recorded in kilograms."])
+def test_another_thing_that_shares_a_word_is_not_contradicted(passage):
+    """HG-022-04: "passenger weights" was matched with "shipping weights" on the word "weights", and the true claim
+    was refused as going against its source. Two things each named for something the other isn't are two things."""
+    g, inv, _r = record({"x": {"k": 0, "n": 3}})
+    write(g, inv, "Passenger weights are recorded in pounds.", [source(g, inv, passage)], scope="The register.")
+    assert "a" not in g.conduct(inv)
+    # the same thing still is: "recorded shipping weights" against shipping weights in kilograms
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "The recorded shipping weights are in pounds.",
+              [source(g, inv, "Shipping weights are recorded in kilograms.")], scope="The register.")
+    assert "SOURCE_CONTRADICTS" in codes(e)
+
+
+@pytest.mark.parametrize("statement", ["The parcel mass is approximately two pounds.",
+                                       "The parcel mass is about 2.2 pounds.",
+                                       "The parcel mass is a little over two pounds."])
+def test_a_quantity_in_another_unit_is_not_a_unit_of_record(statement):
+    """HG-022-05: "the parcel mass is about 2.2 pounds", citing "the parcel mass is one kilogram", was refused: a
+    quantity converted to another unit was read as a claim about which unit the records use. A unit after a number is
+    a quantity; conversions are not checked."""
+    g, inv, _r = record({"x": {"k": 0, "n": 3}})
+    try:
+        write(g, inv, statement, [source(g, inv, "The parcel mass is one kilogram.")],
+              scope="One parcel; 1 kg is about 2.2 pounds.")
+    except GraphError as e:
+        assert "SOURCE_CONTRADICTS" not in [p["code"] for p in e.problems], e.problems