hypgraph 0.7.24__tar.gz → 0.7.25__tar.gz

{hypgraph-0.7.24 → hypgraph-0.7.25}/CHANGELOG.md

@@ -1,5 +1,30 @@
 # Changelog
 
+## 0.7.25 — 2026-11-01: which counts bear on a claim, joined comparisons, boundaries in names
+
+Fixes from an independent audit of 0.7.24 (HG-024-01 to -04); each case below failed on 0.7.24 and is now a test
+(`tests/test_counts_that_bear.py`).
+
+- **A count with no comparison doesn't back one** (HG-024-01). With no comparison of its own, a count of none or all
+  was read the old way, so "3 of 3 routes processed" backed "nothing is longer than 26 km" and "every route is longer
+  than 26 km". A count that states no comparison now doesn't bear on a claim that rules one out
+  (`ABSOLUTE_WITHOUT_COUNT`). A claim with no comparison ("no route ever failed") reads a plain count as before.
+- **A count of one kind doesn't back a claim about another** (HG-024-02). A count and a claim were matched on any shared
+  word, so none of 3 cargo routes longer than 26 km backed "no passenger route is longer than 26 km" while the passenger
+  count was 1 of 3, and backed "no route is longer" too. A count names what it counts in the plural ("cargo routes");
+  where the statement uses that word, the words right before it say which kind. A count backs a claim only if every
+  kind it names is one the statement names; a count of one kind that finds some still refutes a claim about all, and
+  two kinds named apart (cargo, passenger) are left unresolved.
+- **Two comparisons joined in one clause** (HG-024-03). "And" ended the clause, so "no route is shorter than 20 km and
+  longer than 30 km" was refused by a route shorter than 20, and "every route is longer than 10 km and shorter than 30
+  km" went in with "shorter than 30" unread, even with the count that refutes it bound. An "and" or "or" before a
+  comparison with no subject of its own now keeps it in the clause. "No … A or B" and "every … A and B" are false if
+  either part fails; "no … A and B" and "every … A or B" rule out only what meets both, so none of one part backs them
+  and a count of each part on its own leaves them unresolved.
+- **A count's name must say its boundary** (HG-024-04). Only a name pointing the other way was caught: a `>=` count
+  named "routes longer than 26 km", or a `>` count named "26 km or longer", went in. A name that leaves the figure out
+  where the count took it in, or the other way round, is now `MEASUREMENT_MISMATCH`.
+
 ## 0.7.24 — 2026-11-01: what a quantifier needs, where a comparison's boundary falls, one check per extreme
 
 Fixes from an independent audit of 0.7.23 (HG-023-01 to -05); each case below failed on 0.7.23 and is now a test.

{hypgraph-0.7.24 → hypgraph-0.7.25}/PKG-INFO

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

@@ -149,6 +149,23 @@ was taken from a changelog without being checked against the code.*
 > claim layer (subject, property, comparator, threshold, unit, quantifier) so that strong verdicts rest on typed fields
 > rather than prose; that is not built. Released as 0.7.24.
 
+> **Audit of 0.7.24 (2026-11-01), fixed for 0.7.25.** A fifth independent audit named four candidate defects; each
+> reproduced on the PyPI 0.7.24 wheel, plus four of the same kind. A count with no comparison of its own ("3 of 3
+> routes processed") backed "nothing is longer than 26 km" and "every route is longer" (HG-024-01). A count of cargo
+> routes backed a claim about passenger routes, and about every route, because they shared the word "route"
+> (HG-024-02). "And" ended a clause, so a true "no route is shorter than 20 km and longer than 30 km" was refused,
+> and "every route is longer than 10 km and shorter than 30 km" went in with its second half unread, even beside the
+> count that refutes it (HG-024-03). A `>=` count named "longer than 26 km" went in (HG-024-04). A count that states no
+> comparison no longer bears on one; a count backs only a claim whose kinds it names, and kinds named apart are
+> unresolved; a comparison joined by "and" / "or" stays in its clause and is read as both or either; a name must say
+> the boundary its count used. Each case is a regression test written to fail on 0.7.24. Replaying the 1,900 recorded
+> adversarial entries changes 7: one honest correction is no longer refused, and one correction that got in only
+> because an unrelated zero count backed it (the HG-024-01 case) is now refused; none of the entries tries these cases.
+>
+> **Where that stands.** #91 is merged with green CI (17 of 17 checks); from the 0.7.25 wheel in a fresh venv the
+> suite is 574 passed, and hypswarm (118 passed) and hypmesh (37 passed) pass on it. Kinds are read from a plural noun
+> and the words before it, a heuristic; the typed claim layer the audits recommend is not built. Released as 0.7.25.
+
 ## 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.24 → hypgraph-0.7.25}/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.24"
+__version__ = "0.7.25"
 
 from .bundle import anchored, verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.7.24 → hypgraph-0.7.25}/src/hypgraph/checks.py

@@ -219,6 +219,15 @@ def _bound(s: Snap, meas: list) -> tuple[list[tuple[dict, dict]], list[Problem]]
                                     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
+        # "longer than 26" leaves 26 out, "at least 26" and "26 or longer" take it in: a name that says the other
+        # boundary from the one counted says a different count (audit HG-024-04)
+        if not bad and _OPS.get(op) and any(c and not _opposed(c, ("", _OPS[op][0])) and c[2] != _OPS[op][1]
+                                            for _f, c in _clause_comparisons(str(m.get("name") or ""))):
+            problems.append(Problem("MEASUREMENT_MISMATCH", f"measurement {m.get('name')}: its name "
+                                    f"{'leaves out' if _OPS[op][1] else 'takes in'} the figure itself, but result "
+                                    f"{m['result']} counted '{m['key']}' with {op}",
+                                    fix=f"name the count after the comparison it made ({op})"))
+            bad = True
         if not bad:
             good.append((m, rv))
     return good, problems
@@ -430,19 +439,50 @@ def _clause_comparisons(clause: str) -> list[tuple[float, tuple[str, int, bool]
     return out
 
 
-def _absolute_targets(stmt: str, w: str) -> list[tuple[frozenset, frozenset]]:
+# "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)
+
+
+def _clause_end(stmt: str, start: int) -> int:
+    """Where the clause that starts at ``start`` ends. An "and" that joins a second comparison to the first ("no route
+    is shorter than 20 km and longer than 30 km") doesn't end it: the two say one thing (audit HG-024-03)."""
+    for x in _SUBCLAUSE.finditer(stmt, start):
+        if not (x.group(0).lower() == "and" and _JOINED.match(stmt, x.end())):
+            return x.start()
+    return len(stmt)
+
+
+def _target_groups(stmt: str, w: str) -> list[list[tuple[frozenset, frozenset]]]:
     """What an absolute rules out, as (figures, comparisons of the exceptions), one per thing it is about. A comparison
     in its own clause: "nothing longer than 26 km" rules out longer than 26, and "every route is longer than 26 km"
     rules out 26 or shorter (audit HG-023-01). Not "every" in a clause that states its own count ("a count of every
     route finds 1 of 76 shorter than 25 km"): that names the set counted, not a claim about all of it. Else each
-    extreme the statement claims, on its own (HG-023-03)."""
-    out: list[tuple[frozenset, frozenset]] = []
+    extreme the statement claims, on its own (HG-023-03).
+
+    Each group is ruled out together. Two comparisons joined in one clause are two groups where either exception
+    falsifies the claim ("no route is shorter than 20 km or longer than 30 km"; "every route is longer than 10 km and
+    shorter than 30 km"), and one group where only an exception to both does ("no route is shorter than 20 km and
+    longer than 30 km" rules out a route that is both; "every route is shorter than 20 km or longer than 30 km" one that
+    is neither) (audit HG-024-03)."""
+    out: list[list[tuple[frozenset, frozenset]]] = []
     every = bool(_ALL.match(w)) and not _names_stated_count(stmt, w)
     for m in re.finditer(r"\b" + re.escape(w) + r"\b", stmt, re.I):
-        end = next((x.start() for x in _SUBCLAUSE.finditer(stmt, m.end())), len(stmt))
-        for fig, c in _clause_comparisons(stmt[m.end():end]):
-            out.append((frozenset({fig}), frozenset() if c is None else frozenset({_negated(c) if every else c})))
-    return out or _extreme_targets(stmt) or [(frozenset(), frozenset())]
+        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)]
+        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 != ors and (ands != every):
+            out.append(targets)
+        else:
+            out += [[x] for x in targets]
+    return out or [[x] for x in _extreme_targets(stmt) or [(frozenset(), frozenset())]]
+
+
+def _absolute_targets(stmt: str, w: str) -> list[tuple[frozenset, frozenset]]:
+    """Every thing an absolute rules out, each on its own (``_target_groups`` says which go together)."""
+    return [x for group in _target_groups(stmt, w) for x in group]
 
 
 def _claim_directions(stmt: str, w: str = "") -> set[tuple[str, int]]:
@@ -451,19 +491,21 @@ def _claim_directions(stmt: str, w: str = "") -> set[tuple[str, int]]:
     return {(axis, sign) for _f, comps in targets for axis, sign, _strict in comps}
 
 
-def _role(m: dict, rv: dict, a: tuple[int, int], figs: set[float], comps: set) -> str | None:
+def _role(m: dict, rv: dict, a: tuple[int, int], figs: set[float], comps: set, stmt: str = "") -> str | None:
     """What a bound count does to a claim that rules out ``comps`` at ``figs``: 'back' it (none of the exceptions
     found), 'refute' it (some found), or nothing. A count of what lies outside the exceptions is read as its
     complement: none of 3 routes longer than 26 is 3 of 3 at 26 or shorter. A count backs only if what it counted
     covers the exceptions, and refutes only if every one it found is one: two routes at least 26 km don't refute "no
     route is longer than 26", nor does none longer than 26 back "no route is 26 or longer" (audit HG-023-02). Where the
-    name and key could say different comparisons, a label can widen what a count refutes, never what it backs. A
-    count, or a claim, whose comparison can't be told is read as before: none or all backs, some refutes."""
+    name and key could say different comparisons, a label can widen what a count refutes, never what it backs. A count
+    that says no comparison doesn't bear on a claim that rules one out: 3 of 3 routes processed says nothing about
+    routes longer than 26 km (audit HG-024-01). A claim whose comparison can't be told is read as before: none or all
+    backs, some refutes. With ``stmt``, the count must also be about what the claim is (``_subject_fit``)."""
     k, n = a
     cs = _count_comparisons(m, rv)
-    if cs is None and comps:
+    if comps and not cs:
         return None
-    if not cs or not comps:
+    if not comps:
         role = "back" if k in (0, n) else "refute"
     else:
         roles = set()
@@ -484,9 +526,59 @@ def _role(m: dict, rv: dict, a: tuple[int, int], figs: set[float], comps: set) -
     c = _count_figures(m, rv, figs)
     if c and figs and not (c & figs if role == "refute" else c <= figs):
         return None
+    if stmt:
+        covers, apart = _subject_fit(stmt, m)
+        if (role == "back" and not covers) or (role == "refute" and apart):
+            return None
     return role
 
 
+# words a count's name may use for the counting itself, not for what it counts
+_COUNTING = set("count counts counted counting number numbers total totals tally share fraction rate found measured "
+                "checked matching".split())
+# and words that say how many, not which kind: "nothing worth more", "every route"
+_HOW_MANY = set("nothing none never nobody every always ever each whole entire".split())
+
+
+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)
+        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
+    return out
+
+
+def _subject_fit(stmt: str, m: dict) -> tuple[bool, bool]:
+    """Is a count about what a claim is about? Returns (covers, apart). A count names what it counts in the plural
+    ("cargo routes", "fitting selections"); where the statement uses that word too, the words right before it on each
+    side say which kind: "cargo routes" are cargo routes. The count covers the claim if every kind it names is one the
+    statement names too: none of 3 cargo routes longer than 26 km says nothing of passenger routes, nor of every route
+    (audit HG-024-02). They are apart if each names a kind the other doesn't (cargo, passenger); a count of all routes
+    with one longer may still be about the passenger route. A count that names nothing the statement does is read as
+    before."""
+    said = re.findall(r"[a-z]+", stmt.lower())
+    stems = [L.content_words(w) for w in said]
+    about = set().union(*stems) if stems else set()
+    text = f"{m.get('name') or ''} . {str(m.get('key') or '').replace('_', ' ')}".lower()
+    words = re.findall(r"[a-z]+|\.", text)
+    mine = L.content_words(text)
+    covers, apart = True, False
+    for i, w in enumerate(words):
+        head = L.content_words(w)
+        plural = w.endswith("s") and not w.endswith("ss")
+        if not head or not plural or w in _DIRECTION_OF or w in _COUNTING | _HOW_MANY or not head & about:
+            continue
+        kinds = _modifiers(words, i) - about
+        theirs = set().union(*(_modifiers(said, j) for j, s in enumerate(stems) if s & head)) - mine
+        covers = covers and not kinds
+        apart = apart or bool(kinds and theirs)
+    return covers, apart
+
+
 def _pinned(m: dict, rv: dict, figs: set[float]) -> bool:
     """A count at the claim's own figure: when it refutes the claim, it does whatever else is bound beside it."""
     return bool(figs) and bool(_count_figures(m, rv, figs) & figs)
@@ -502,11 +594,19 @@ def _absolutes(stmt: str, scope: str, body: dict, bound: list) -> list[Problem]:
     out: list[Problem] = []
     seen: set[tuple] = set()
     for w in words:                                  # one check per thing the absolutes rule out
-        for figs, comps in _absolute_targets(stmt, w):
-            if (figs, comps, _ALL.match(w) is None) not in seen:
-                seen.add((figs, comps, _ALL.match(w) is None))
-                out += [p for p in _absolute(stmt, scope, body, bound, w, words, set(figs), set(comps))
-                        if p.text() not in {q.text() for q in out}]
+        for group in _target_groups(stmt, w):
+            if (tuple(group), _ALL.match(w) is None) in seen:
+                continue
+            seen.add((tuple(group), _ALL.match(w) is None))
+            got = [_absolute(stmt, scope, body, bound, w, words, set(figs), set(comps)) for figs, comps in group]
+            if len(group) > 1:                       # ruled out together: none of one part means none of both
+                if any(not g for g in got):
+                    continue
+                got = [g for g in got if not any(p.code == "COUNT_CONTRADICTS" for p in g)][:1] or [[Problem(
+                    "ABSOLUTE_WITHOUT_COUNT", f"'{w}' rules out what meets both comparisons at once: a count of each "
+                    "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}]
     if not any(p.code == "COUNT_CONTRADICTS" for p in out):
         out += _superlative_contradicted(stmt, bound)
     return out
@@ -514,7 +614,7 @@ 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],
               comps: set = frozenset()) -> list[Problem]:
-    arms = [(m, rv, a, role) for m, rv in bound if (a := _arm(rv)) and (role := _role(m, rv, a, figs, comps))]
+    arms = [(m, rv, a, role) for m, rv in bound if (a := _arm(rv)) and (role := _role(m, rv, a, figs, comps, stmt))]
     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, role in arms if role == "refute" and _pinned(m, rv, figs)
@@ -673,7 +773,7 @@ def _superlative_contradicted(stmt: str, bound: list) -> list[Problem]:
     about = L.content_words(stmt)
     for w, figs, comps in _extreme_targets(stmt, named=True):
         rel = [(m, rv, a, role) for m, rv in bound if (a := _arm(rv))
-               and (role := _role(m, rv, a, set(figs), set(comps)))
+               and (role := _role(m, rv, a, set(figs), set(comps), stmt))
                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)

hypgraph-0.7.25/tests/test_counts_that_bear.py

@@ -0,0 +1,160 @@
+"""Which counts bear on a claim, and what two joined comparisons rule out (audit of 0.7.24, HG-024-01..04).
+
+A count of routes processed says nothing about routes longer than 26 km. A count of cargo routes says nothing about
+passenger routes, nor about every route. "No route is shorter than 20 km and longer than 30 km" rules out a route that
+is both, so a route shorter than 20 doesn't show it false; "every route is longer than 10 km and shorter than 30 km" is
+false if either fails. And a count made with ">=" is not one of routes "longer than" its figure."""
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+
+SCOPE = "The three surveyed routes, of 18, 25 and 35 km, against 10, 20, 26 and 30 km marks."
+
+
+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.",
+                values=values, links=[{"rel": "produced", "from": run["id"]}])["id"]
+    return g, inv, r
+
+
+def write(g, inv, statement, links, meas=(), scope=SCOPE):
+    return g.author("a").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}
+
+
+def typed(k, op=">", figure=26):
+    return {"k": k, "n": 3, "figure": figure, "op": op}
+
+
+@pytest.mark.parametrize("statement,k", [("Nothing is longer than 26 km among the 3 routes.", 3),
+                                         ("No route is longer than 26 km among the 3 routes.", 3),
+                                         ("Every route is longer than 26 km among the 3 routes.", 0),
+                                         ("Every route is longer than 26 km among the 3 routes.", 3)])
+def test_a_count_with_no_comparison_does_not_back_one(statement, k):
+    """HG-024-01: with no comparison of its own, a count of none or all backed any claim that ruled one out."""
+    g, inv, r = record({"processed": {"k": k, "n": 3}})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, statement, [r], [count(r, "processed", "routes processed", k)])
+    assert codes(e) == ["ABSOLUTE_WITHOUT_COUNT"]
+
+
+def test_a_claim_with_no_comparison_reads_a_plain_count_as_before():
+    g, inv, r = record({"failed": {"k": 0, "n": 3}})
+    write(g, inv, "No route ever failed to load among the 3 routes.", [r],
+          [count(r, "failed", "routes that failed to load", 0)])
+
+
+@pytest.mark.parametrize("statement", ["No passenger route is longer than 26 km among the 3 routes.",
+                                       "Nothing is longer than 26 km among the 3 passenger routes.",
+                                       "No route is longer than 26 km among the 3 routes."])
+def test_a_count_of_another_kind_does_not_back_the_claim(statement):
+    """HG-024-02: none of 3 cargo routes longer backed a claim about passenger routes (1 of 3 of them longer), and about
+    every route, because the count and the claim shared the word "route"."""
+    g, inv, r = record({"cargo_longer_26": typed(0), "passenger_longer_26": typed(1)})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, statement, [r], [count(r, "cargo_longer_26", "cargo routes longer than 26 km", 0)])
+    assert codes(e) == ["ABSOLUTE_WITHOUT_COUNT"]
+
+
+@pytest.mark.parametrize("name", ["passenger routes longer than 26 km", "routes longer than 26 km"])
+def test_a_count_of_the_same_kind_or_all_of_them_backs_it(name):
+    g, inv, r = record({"longer_26": typed(0)})
+    write(g, inv, "No passenger route is longer than 26 km among the 3 routes.", [r],
+          [count(r, "longer_26", name, 0)])
+
+
+def test_a_count_of_one_kind_still_refutes_a_claim_about_all():
+    g, inv, r = record({"cargo_longer_26": typed(1)})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "No route is longer than 26 km among the 3 routes.", [r],
+              [count(r, "cargo_longer_26", "cargo routes longer than 26 km", 1)])
+    assert codes(e) == ["COUNT_CONTRADICTS"]
+
+
+def test_two_kinds_named_apart_do_not_contradict():
+    g, inv, r = record({"cargo_longer_26": typed(1)})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "No passenger route is longer than 26 km among the 3 routes.", [r],
+              [count(r, "cargo_longer_26", "cargo routes longer than 26 km", 1)])
+    assert codes(e) == ["ABSOLUTE_WITHOUT_COUNT"]
+
+
+BOTH = {"shorter_20": typed(1, "<", 20), "longer_30": typed(1, ">", 30), "shorter_10": typed(0, "<", 10),
+        "longer_10": typed(3, ">", 10), "shorter_30": typed(2, "<", 30)}
+
+
+def test_no_route_both_shorter_and_longer_is_not_refuted_by_either():
+    """HG-024-03: "and" ended the clause, so a route shorter than 20 refuted a claim that rules out only a route both
+    shorter than 20 and longer than 30. With no count of both, it's unresolved."""
+    g, inv, r = record(BOTH)
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "No route is shorter than 20 km and longer than 30 km among the 3 routes.", [r],
+              [count(r, "shorter_20", "routes shorter than 20 km", 1),
+               count(r, "longer_30", "routes longer than 30 km", 1)])
+    assert codes(e) == ["ABSOLUTE_WITHOUT_COUNT"]
+
+
+def test_none_of_one_part_backs_none_of_both():
+    g, inv, r = record(BOTH)
+    write(g, inv, "No route is shorter than 10 km and longer than 30 km among the 3 routes.", [r],
+          [count(r, "shorter_10", "routes shorter than 10 km", 0)])
+
+
+def test_no_route_shorter_or_longer_is_refuted_by_either():
+    g, inv, r = record(BOTH)
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "No route is shorter than 20 km or longer than 30 km among the 3 routes.", [r],
+              [count(r, "shorter_20", "routes shorter than 20 km", 1),
+               count(r, "longer_30", "routes longer than 30 km", 1)])
+    assert "COUNT_CONTRADICTS" in codes(e)
+
+
+def test_every_route_between_two_marks_needs_both():
+    """The same split left "shorter than 30 km" unread after "every route is longer than 10 km and": the claim went in
+    with 2 of 3 shorter than 30 bound beside it."""
+    g, inv, r = record(BOTH)
+    statement = "Every route is longer than 10 km and shorter than 30 km among the 3 routes."
+    with pytest.raises(GraphError) as e:
+        write(g, inv, statement, [r], [count(r, "longer_10", "routes longer than 10 km", 3)])
+    assert codes(e) == ["ABSOLUTE_WITHOUT_COUNT"]
+    with pytest.raises(GraphError) as e:
+        write(g, inv, statement, [r], [count(r, "longer_10", "routes longer than 10 km", 3),
+                                       count(r, "shorter_30", "routes shorter than 30 km", 2)])
+    assert codes(e) == ["COUNT_CONTRADICTS"]
+
+
+def test_and_with_a_subject_of_its_own_still_ends_the_clause():
+    g, inv, r = record(BOTH)
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "No route is shorter than 20 km and the register lists 3 routes.", [r],
+              [count(r, "shorter_20", "routes shorter than 20 km", 1)])
+    assert codes(e) == ["COUNT_CONTRADICTS"]
+
+
+@pytest.mark.parametrize("op,name", [(">=", "routes longer than 26 km"), (">", "routes 26 km or longer"),
+                                     (">", "routes at least 26 km"), ("<", "routes no longer than 26 km")])
+def test_a_name_must_say_the_boundary_the_count_used(op, name):
+    """HG-024-04: only a name pointing the other way was caught; "longer than 26" on a ">=" count went in."""
+    g, inv, r = record({"routes_26": typed(2, op)})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "2 of 3 routes are at least 26 km long.", [r], [count(r, "routes_26", name, 2)])
+    assert "MEASUREMENT_MISMATCH" in codes(e)
+
+
+@pytest.mark.parametrize("op,name", [(">=", "routes at least 26 km"), (">=", "routes 26 km or longer"),
+                                     (">", "routes longer than 26 km"), ("<=", "routes no longer than 26 km")])
+def test_a_name_that_says_the_boundary_is_accepted(op, name):
+    g, inv, r = record({"routes_26": typed(2, op)})
+    write(g, inv, "2 of 3 routes are at least 26 km long.", [r], [count(r, "routes_26", name, 2)])