hypgraph 0.7.24__tar.gz → 0.7.26__tar.gz

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

@@ -1,5 +1,51 @@
 # Changelog
 
+## 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
+(`tests/test_what_a_count_is_of.py`).
+
+- **A count names its kind in the singular too** (HG-025-01). Kinds were read only before a plural, so none of 3
+  "cargo route longer than 26 km" (or "cargo longer than 26 km") backed "no passenger route is longer than 26 km"
+  while the passenger count was 1 of 3. What a count names before its comparison is now read singular or plural: a
+  count of cargo routes neither backs nor refutes a claim about passenger routes. A word that says what was compared
+  ("selections worth more") isn't read as the kind, and a bound in the statement ("the limit is at most 49 kg") isn't
+  what the claim is about.
+- **A count's name can't change what its key counted** (HG-025-02). A count the lab keyed `route_speed_above_26`,
+  named "routes longer than 26 km" by the claimant, backed a claim about length. The key is the result's own name for
+  what it counted: a measurement whose name compares along another axis (length, not speed), or whose key counts a
+  thing neither the name nor the statement says ("cargo" under a name for passenger routes), is now
+  `MEASUREMENT_MISMATCH`. "route length above 26 km" still names a count of routes longer than 26 km.
+- **"And" with "or" in one clause is left unresolved** (HG-025-03). The parts were checked one by one, so routes of 5,
+  20 and 25 km, which make "every route is longer than 10 km and shorter than 30 km or shorter than 6 km" true, gave
+  `COUNT_CONTRADICTS`. Which parts go together isn't settled by the words, so no count of a part backs or refutes such
+  a clause: it is `ABSOLUTE_WITHOUT_COUNT` until a count of the whole condition is bound, or the claim is split.
+
+## 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.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.7.24
+Version: 0.7.26
 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/
@@ -38,13 +38,22 @@ The evidence layer for AI research agents.<br>
 <a href="https://hypgraph.com">hypgraph.com</a> · <a href="https://hypgraph.com/agents/">for agents</a> ·
 <a href="https://hypgraph.com/engineers/">for engineers</a> · <a href="https://hypgraph.com/spec/">record format</a></p>
 
+<p align="center"><picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://hypgraph.com/assets/readme/record-dark.png">
+  <img src="https://hypgraph.com/assets/readme/record-light.png" width="880" alt="The Graph view of a real research record: one question at the centre, 27 hypotheses around it, experiments and runs fanning out into 90 results, and 22 claims at the rim">
+</picture></p>
+<p align="center"><sub>A real research record in the HypGraph UI: one question, 27 hypotheses, 12 experiments and their runs, 90 results, 22 claims, 395 hash-chained events. <a href="https://hypgraph.com/examples/">Open an example live</a>.</sub></p>
+
 ---
 
-Agents doing research write fluent summaries. Some of the numbers in them match no result. A clean red-team run of
-50 prompts becomes "the model never leaks". A search too weak to find anything becomes "ruled out", and three copies
-of one result get counted as three lines of evidence. Then other claims, decisions and deployments get built on top.
-HypGraph is the record agents write into instead. It checks every claim as it's written, does the arithmetic the
-writer skipped, and refuses:
+Research agents write fluently, and fluency hides overclaims. Fifty clean prompts become "the model never leaks". A
+search too weak to find anything becomes "ruled out". Three copies of one result become three independent lines of
+evidence, and a number appears that no result contains. Every sentence reads fine, and the next claim, decision or
+deployment gets built on top of it.
+
+HypGraph is the record agents write into instead of prose. It checks each claim the moment it's written: its numbers
+must come from a result, its "never" needs the trials behind it, its "better" needs both sides measured. When the
+arithmetic doesn't hold, the claim is refused, with a code, the math, and the sentence that would be honest:
 
 ```text
 $ hypgraph add claim statement="The model never leaks training data." exposure=1000000 exposure_unit=users …
@@ -61,6 +70,15 @@ The honest version goes in, and it carries its consequence wherever it's read:
 active claim · unchecked · 1 independent line of support · … · 0 of 50 = at most 5.8% at 95%, up to 58,155 of 1,000,000 not ruled out
 ```
 
+On the website, the same engine refused these as the page was built. Each gets a code and what to fix; the
+rewrite underneath, on the same evidence, got in:
+
+<p align="center"><a href="https://hypgraph.com/play/"><picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://hypgraph.com/assets/readme/refusals-dark.png">
+  <img src="https://hypgraph.com/assets/readme/refusals-light.png" width="880" alt="Three overclaims struck through — 'always beats the baseline', '5 points better', 'never leaks training data' — each with its refusal code and what to fix, and the honest rewrite accepted as CL1, CL2, CL3">
+</picture></a></p>
+<p align="center"><sub>Try to get a claim past it yourself: <a href="https://hypgraph.com/play/">hypgraph.com/play</a>.</sub></p>
+
 ## The arithmetic of never
 
 "Never" is the most expensive word in research, because everything built on it inherits it. Zero failures in *n*
@@ -133,6 +151,15 @@ Nothing in the record is ever *set* as known. How well each claim is known is **
 Every write is an event in a **SHA-256 hash chain**. A record can be handed to a reviewer, a regulator or another
 team, and they can verify it without trusting you.
 
+Records can build on each other. A source in one record pins a node of another: the version it read and that
+version's hash. The UI draws every pinned record beside yours, verifies each one, and checks each pin against it.
+
+<p align="center"><a href="https://hypgraph.com/examples/linked/#view=graph"><picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://hypgraph.com/assets/readme/linked-dark.png">
+  <img src="https://hypgraph.com/assets/readme/linked-light.png" width="880" alt="Three hash-chained records drawn together — London's water 1854–1866, Broad Street 1854 and East London 1866 — joined by pinned references labelled with the version each one read, every pin checked">
+</picture></a></p>
+<p align="center"><sub>Three records, each its own hash chain, joined only by pinned references. <a href="https://hypgraph.com/examples/linked/#view=graph">Open it live</a>.</sub></p>
+
 ## One record, five disciplines
 
 The rules above are the scientific case written as code. A **profile** says what a domain means by evidence,

{hypgraph-0.7.24 → hypgraph-0.7.26}/README.md

@@ -6,13 +6,22 @@ The evidence layer for AI research agents.<br>
 <a href="https://hypgraph.com">hypgraph.com</a> · <a href="https://hypgraph.com/agents/">for agents</a> ·
 <a href="https://hypgraph.com/engineers/">for engineers</a> · <a href="https://hypgraph.com/spec/">record format</a></p>
 
+<p align="center"><picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://hypgraph.com/assets/readme/record-dark.png">
+  <img src="https://hypgraph.com/assets/readme/record-light.png" width="880" alt="The Graph view of a real research record: one question at the centre, 27 hypotheses around it, experiments and runs fanning out into 90 results, and 22 claims at the rim">
+</picture></p>
+<p align="center"><sub>A real research record in the HypGraph UI: one question, 27 hypotheses, 12 experiments and their runs, 90 results, 22 claims, 395 hash-chained events. <a href="https://hypgraph.com/examples/">Open an example live</a>.</sub></p>
+
 ---
 
-Agents doing research write fluent summaries. Some of the numbers in them match no result. A clean red-team run of
-50 prompts becomes "the model never leaks". A search too weak to find anything becomes "ruled out", and three copies
-of one result get counted as three lines of evidence. Then other claims, decisions and deployments get built on top.
-HypGraph is the record agents write into instead. It checks every claim as it's written, does the arithmetic the
-writer skipped, and refuses:
+Research agents write fluently, and fluency hides overclaims. Fifty clean prompts become "the model never leaks". A
+search too weak to find anything becomes "ruled out". Three copies of one result become three independent lines of
+evidence, and a number appears that no result contains. Every sentence reads fine, and the next claim, decision or
+deployment gets built on top of it.
+
+HypGraph is the record agents write into instead of prose. It checks each claim the moment it's written: its numbers
+must come from a result, its "never" needs the trials behind it, its "better" needs both sides measured. When the
+arithmetic doesn't hold, the claim is refused, with a code, the math, and the sentence that would be honest:
 
 ```text
 $ hypgraph add claim statement="The model never leaks training data." exposure=1000000 exposure_unit=users …
@@ -29,6 +38,15 @@ The honest version goes in, and it carries its consequence wherever it's read:
 active claim · unchecked · 1 independent line of support · … · 0 of 50 = at most 5.8% at 95%, up to 58,155 of 1,000,000 not ruled out
 ```
 
+On the website, the same engine refused these as the page was built. Each gets a code and what to fix; the
+rewrite underneath, on the same evidence, got in:
+
+<p align="center"><a href="https://hypgraph.com/play/"><picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://hypgraph.com/assets/readme/refusals-dark.png">
+  <img src="https://hypgraph.com/assets/readme/refusals-light.png" width="880" alt="Three overclaims struck through — 'always beats the baseline', '5 points better', 'never leaks training data' — each with its refusal code and what to fix, and the honest rewrite accepted as CL1, CL2, CL3">
+</picture></a></p>
+<p align="center"><sub>Try to get a claim past it yourself: <a href="https://hypgraph.com/play/">hypgraph.com/play</a>.</sub></p>
+
 ## The arithmetic of never
 
 "Never" is the most expensive word in research, because everything built on it inherits it. Zero failures in *n*
@@ -101,6 +119,15 @@ Nothing in the record is ever *set* as known. How well each claim is known is **
 Every write is an event in a **SHA-256 hash chain**. A record can be handed to a reviewer, a regulator or another
 team, and they can verify it without trusting you.
 
+Records can build on each other. A source in one record pins a node of another: the version it read and that
+version's hash. The UI draws every pinned record beside yours, verifies each one, and checks each pin against it.
+
+<p align="center"><a href="https://hypgraph.com/examples/linked/#view=graph"><picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://hypgraph.com/assets/readme/linked-dark.png">
+  <img src="https://hypgraph.com/assets/readme/linked-light.png" width="880" alt="Three hash-chained records drawn together — London's water 1854–1866, Broad Street 1854 and East London 1866 — joined by pinned references labelled with the version each one read, every pin checked">
+</picture></a></p>
+<p align="center"><sub>Three records, each its own hash chain, joined only by pinned references. <a href="https://hypgraph.com/examples/linked/#view=graph">Open it live</a>.</sub></p>
+
 ## One record, five disciplines
 
 The rules above are the scientific case written as code. A **profile** says what a domain means by evidence,

{hypgraph-0.7.24 → hypgraph-0.7.26}/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.26 (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.26}/docs/RELEASE-READINESS.md

@@ -149,6 +149,38 @@ 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.
+
+> **Audit of 0.7.25 (2026-11-01), fixed for 0.7.26.** A sixth independent audit named three defects; each reproduced on
+> the PyPI 0.7.25 wheel. Kinds were read only before a plural, so none of 3 "cargo route longer than 26 km" backed "no
+> passenger route is longer than 26 km" while the passenger count was 1 of 3 (HG-025-01). A count the lab keyed
+> `route_speed_above_26`, named "routes longer than 26 km" by the claimant, backed a claim about length (HG-025-02). A
+> clause joining comparisons with both "and" and "or" was checked part by part, so a true one drew
+> `COUNT_CONTRADICTS` (HG-025-03). What a count names before its comparison is now read singular or plural; a name
+> that compares along another axis than its key, or a key that counts a kind neither the name nor the statement says,
+> is `MEASUREMENT_MISMATCH`; a mixed "and" / "or" clause is unresolved until the whole condition is counted. Each case
+> is a regression test written to fail on 0.7.25. Replaying the 1,900 recorded adversarial entries changes none; the
+> replay caught two over-reaches of a first draft (a value word, "selections worth more", read as the kind; a bound,
+> "the limit is at most 49 kg", read as the subject), now tests too.
+>
+> **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.
+
 ## 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.26}/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.26"
 
 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.26}/src/hypgraph/checks.py

@@ -185,8 +185,9 @@ def _matches_stat(printed: tuple, candidates: list[float]) -> bool:
     return printed[1] >= 1 and _matches(printed, candidates)
 
 
-def _bound(s: Snap, meas: list) -> tuple[list[tuple[dict, dict]], list[Problem]]:
-    """Measurements that check out against their results, and problems with the rest."""
+def _bound(s: Snap, meas: list, stmt: str = "") -> tuple[list[tuple[dict, dict]], list[Problem]]:
+    """Measurements that check out against their results, and problems with the rest. With ``stmt``, the claim's
+    statement: what a key says it counted must be said by the measurement's name or by the statement."""
     good, problems = [], []
     for i, m in enumerate(meas):
         if not isinstance(m, dict) or not m.get("result") or not m.get("key"):
@@ -219,11 +220,52 @@ 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
+        # the key is the result's own name for what it counted, written by whoever ran it; the measurement's name is
+        # the claimant's. A name may shorten the key, not change it: "routes longer than 26 km" isn't a count of
+        # route_speed_above_26, nor of routes_faster_than_26 (audit HG-025-02)
+        key = str(m["key"]).replace("_", " ")
+        named_axes = {c[0] for c in _comparisons_in(str(m.get("name") or "")) if c[0]}
+        key_axes = {c[0] for c in _comparisons_in(key) if c[0]}
+        if not bad and named_axes and key_axes and not named_axes & key_axes:
+            problems.append(Problem("MEASUREMENT_MISMATCH", f"measurement {m.get('name')}: its name compares "
+                                    f"{_axis_words(named_axes)}, but result {m['result']} counted '{m['key']}', which "
+                                    f"compares {_axis_words(key_axes)}",
+                                    fix="name the count after what it compared, or bind the count that compared that"))
+            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}")
+        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 "
+                                    f"counted ({', '.join(sorted(_key_words(key, unsaid)))})",
+                                    fix="name the count after what it counted, or bind the count of what the claim "
+                                        "is about"))
+            bad = True
         if not bad:
             good.append((m, rv))
     return good, problems
 
 
+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))
+
+
+def _key_words(key: str, stems: set[str]) -> set[str]:
+    """The words of ``key`` whose stems are ``stems``, as written."""
+    return {w for w in re.findall(r"[a-z]+", key.lower()) if L.content_words(w) & stems} or stems
+
+
 def _exposure_note(bound_rate: float, body: dict) -> str:
     x = body.get("exposure")
     if not isinstance(x, (int, float)) or x <= 0:
@@ -430,19 +472,59 @@ 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]]:
+# a target group whose parts are joined by both "and" and "or" (``_target_groups``)
+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)
+
+
+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).
+
+    A clause that joins comparisons with both "and" and "or" ("every route is longer than 10 km and shorter than 30 km
+    or shorter than 6 km") is one group marked ``MIXED``: which parts go together depends on a grouping the words don't
+    settle, so no count of a part backs or refutes it (audit HG-025-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 and ors:
+            out.append([MIXED, *targets])
+        elif 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 if x is not MIXED]
 
 
 def _claim_directions(stmt: str, w: str = "") -> set[tuple[str, int]]:
@@ -451,19 +533,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 +568,150 @@ 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_of(text: str) -> set[str]:
+    """What a count against a figure is of: the content words right before its first comparison ("cargo route longer
+    than 26 km" and "cargo_routes_longer_26" give {cargo, route}; "speed above 26" {speed}); empty when it makes no
+    comparison or names nothing before it. Singular or plural alike (audit HG-025-01)."""
+    words = [w for w in re.findall(r"[a-z]+|\d[\d.,]*", text.lower().replace("_", " ")) if w not in _COPULAS]
+    i = next((j for j, w in enumerate(words) if w in _DIRECTION_OF or w == "at" and words[j + 1:j + 2] in
+              (["least"], ["most"])), None)
+    return _modifiers(words, i) if i else set()
+
+
+def _subject_parts(text: str) -> tuple[set[str], set[str]]:
+    """``_subject_of`` split into its head, the word right before the comparison, and the words before that: "cargo
+    route longer" gives ({route}, {cargo}), "fitting selections worth more" ({selection}, {fit})."""
+    words = [w for w in re.findall(r"[a-z]+|\d[\d.,]*", text.lower().replace("_", " ")) if w not in _COPULAS]
+    i = next((j for j, w in enumerate(words) if w in _DIRECTION_OF or w == "at" and words[j + 1:j + 2] in
+              (["least"], ["most"])), None)
+    if not i:
+        return set(), set()
+    whole = _modifiers(words, i)
+    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
+    return head, whole - head
+
+
+# words between what a count is of and its comparison that say what was compared, not which thing
+_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)}
+
+
+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}
+
+
+def _subjects_at(stmt: str, axes: set[str]) -> set[str]:
+    """What a statement's comparisons along ``axes`` are about: "no passenger route is longer than 26 km" gives
+    {passenger, route} for length; "nothing worth more" nothing. A bound ("the limit is at most 49 kg") is not one."""
+    words = [w for w in re.findall(r"[a-z]+|\d[\d.,]*", stmt.lower()) if w not in _COPULAS | _MEASURED_BY]
+    return set().union(*(_modifiers(words, j) for j, w in enumerate(words) if w in _DIRECTION_OF
+                         and _DIRECTION_OF[w][0] in axes and words[j - 1:j] != ["at"]))
+
+
+def _kinds_named(stmt: str) -> set[str]:
+    """The kinds a statement names for what it is about: the words before its comparison ("no passenger route is
+    longer" gives {passenger, route}) and before a plural in a phrase that says what it ranges over ("among the 3
+    passenger routes" gives {passenger}; "the recorded weights" and "the limit applies" name nothing it ranges over)."""
+    said = re.findall(r"[a-z]+|\d[\d.,]*", stmt.lower())
+    out = _subject_of(stmt)
+    for i, w in enumerate(said):
+        if not (w.endswith("s") and not w.endswith("ss") and L.content_words(w)):
+            continue
+        mods = _modifiers(said, i)
+        j = i - 1
+        while j >= 0 and L.content_words(said[j]) & mods:
+            j -= 1
+        while j >= 0 and (said[j] in _DETERMINERS or said[j][0].isdigit()):
+            j -= 1
+        if j >= 0 and said[j] in _PREPOSITIONS:
+            out |= mods
+    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.
+
+    The same holds for what a count names before its comparison, singular or plural: "cargo route longer than 26 km"
+    and "cargo longer than 26 km" are of cargo routes, and back no claim about passenger routes (audit HG-025-01). A
+    count whose subject the statement doesn't name at all ("speed above 26" against a claim about length) neither backs
+    nor refutes it."""
+    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)
+    parts = [_subject_parts(str(m.get(f) or "")) for f in ("name", "key")]
+    head, mods = parts[0][0] | parts[1][0], parts[0][1] | parts[1][1]
+    if head:
+        subject = head | mods
+        if not _unsaid(head, stmt):      # the statement says the count's head: its other words must be said too
+            kinds = _unsaid(mods, stmt)
+            theirs = set().union(*(_modifiers(said, j) for j, s in enumerate(stems) if s & head)) - subject
+            apart = apart or bool(kinds and theirs)
+        else:                            # a head the statement doesn't say only matters where it names a kind itself
+            named = _kinds_named(stmt)
+            kinds = _unsaid(subject, stmt) if named else set()
+            axes = {c[0] for f in ("name", "key") for c in _comparisons_in(str(m.get(f) or "").replace("_", " "))}
+            theirs = _subjects_at(stmt, axes)
+            apart = apart or bool(theirs and not theirs & subject)
+        covers = covers and not kinds
+    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 +727,27 @@ 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))
+            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)
+                if p.text() not in {q.text() for q in out}:
+                    out.append(p)
+                continue
+            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 +755,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 +914,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)
@@ -1377,7 +1618,7 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
     if kind in ("finding", "exclusion", "inconclusive") and not support:
         problems.append(Problem("EVIDENCE_MISSING", "link the evidence: at least one result, claim or source that "
                                 "supports it (links: {\"rel\": \"supports\", \"from\": <result id>, \"why\": …})"))
-    bound, bad = _bound(s, body.get("measurements") or [])
+    bound, bad = _bound(s, body.get("measurements") or [], stmt)
     problems += bad
     clean = _DATE.sub(" ", _LABEL.sub(" ", stmt))
     plain, stat = derived_numbers(bound)