hypgraph 0.7.25__tar.gz → 0.7.26__tar.gz

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

@@ -1,5 +1,26 @@
 # 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

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

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

@@ -166,6 +166,21 @@ was taken from a changelog without being checked against the code.*
 > 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.25 → 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.25"
+__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.25 → 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"):
@@ -228,11 +229,43 @@ def _bound(s: Snap, meas: list) -> tuple[list[tuple[dict, dict]], list[Problem]]
                                     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:
@@ -439,6 +472,9 @@ def _clause_comparisons(clause: str) -> list[tuple[float, tuple[str, int, bool]
     return out
 
 
+# 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)
@@ -464,7 +500,11 @@ def _target_groups(stmt: str, w: str) -> list[list[tuple[frozenset, frozenset]]]
     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)."""
+    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):
@@ -473,7 +513,9 @@ def _target_groups(stmt: str, w: str) -> list[list[tuple[frozenset, frozenset]]]
                    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):
+        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]
@@ -482,7 +524,7 @@ def _target_groups(stmt: str, w: str) -> list[list[tuple[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]
+    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]]:
@@ -552,6 +594,77 @@ def _modifiers(words: list[str], i: int) -> set[str]:
     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
@@ -559,7 +672,12 @@ def _subject_fit(stmt: str, m: dict) -> tuple[bool, bool]:
     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."""
+    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()
@@ -576,6 +694,21 @@ def _subject_fit(stmt: str, m: dict) -> tuple[bool, bool]:
         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
 
 
@@ -598,6 +731,14 @@ def _absolutes(stmt: str, scope: str, body: dict, bound: list) -> list[Problem]:
             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):
@@ -1477,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)

hypgraph-0.7.26/tests/test_what_a_count_is_of.py

@@ -0,0 +1,152 @@
+"""What a count is of, what its key says it compared, and comparisons joined by both "and" and "or" (audit of 0.7.25,
+HG-025-01..03).
+
+A count of the cargo route is a count of cargo routes, singular or plural, and says nothing about passenger routes. A
+count the lab keyed `route_speed_above_26` is a count of speeds, whatever the claimant names it. And "every route is
+longer than 10 km and shorter than 30 km or shorter than 6 km" groups its parts in a way the words don't settle, so no
+count of one part shows it true or false."""
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+
+SCOPE = "The three surveyed routes, of 5, 20 and 25 km, against 6, 10, 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}
+
+
+PASSENGER = ["No passenger route is longer than 26 km among the 3 routes.",
+             "Nothing is longer than 26 km among the 3 passenger routes."]
+
+
+@pytest.mark.parametrize("statement", PASSENGER)
+@pytest.mark.parametrize("key,name", [("cargo_route_longer_26", "cargo route longer than 26 km"),
+                                      ("cargo_longer_26", "cargo longer than 26 km"),
+                                      ("longer_26", "cargo route longer than 26 km")])
+def test_a_count_of_another_kind_in_the_singular_does_not_back_the_claim(statement, key, name):
+    """HG-025-01: kinds were read only before a plural, so none of 3 "cargo route longer than 26 km" backed a claim
+    about passenger routes while the passenger count was 1 of 3."""
+    g, inv, r = record({key: typed(0), "passenger_routes_longer_26": typed(1)})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, statement, [r], [count(r, key, name, 0)])
+    assert codes(e) == ["ABSOLUTE_WITHOUT_COUNT"]
+
+
+@pytest.mark.parametrize("statement", PASSENGER)
+@pytest.mark.parametrize("key,name", [("passenger_route_longer_26", "passenger route longer than 26 km"),
+                                      ("passenger_routes_longer_26", "routes longer than 26 km"),
+                                      ("longer_26", "route longer than 26 km")])
+def test_a_count_of_the_same_kind_or_of_all_backs_it(statement, key, name):
+    g, inv, r = record({key: typed(0)})
+    write(g, inv, statement, [r], [count(r, key, name, 0)])
+
+
+def test_a_count_of_another_kind_in_the_singular_does_not_contradict():
+    g, inv, r = record({"cargo_route_longer_26": typed(1)})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, PASSENGER[0], [r], [count(r, "cargo_route_longer_26", "cargo route longer than 26 km", 1)])
+    assert codes(e) == ["ABSOLUTE_WITHOUT_COUNT"]
+
+
+@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."])
+@pytest.mark.parametrize("key", ["route_speed_above_26", "speed_above_26", "routes_faster_than_26"])
+def test_a_name_cannot_turn_a_count_of_one_property_into_another(statement, key):
+    """HG-025-02: a count the lab keyed for speed, named "routes longer than 26 km" by the claimant, backed a claim
+    about length. The key says what was counted; a name that compares something else is refused."""
+    g, inv, r = record({key: typed(0)})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, statement, [r], [count(r, key, "routes longer than 26 km", 0)])
+    assert "MEASUREMENT_MISMATCH" in codes(e) and "COUNT_CONTRADICTS" not in codes(e)
+
+
+def test_a_name_cannot_turn_a_count_of_one_kind_into_another():
+    g, inv, r = record({"cargo_longer_26": typed(0), "passenger_longer_26": typed(1)})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, PASSENGER[0], [r], [count(r, "cargo_longer_26", "passenger routes longer than 26 km", 0)])
+    assert "MEASUREMENT_MISMATCH" in codes(e)
+
+
+@pytest.mark.parametrize("key,name", [("routes_longer_26", "routes longer than 26 km"),
+                                      ("route_length_above_26", "route length above 26 km"),
+                                      ("passenger_routes_longer_26", "routes longer than 26 km")])
+def test_a_name_that_keeps_what_the_key_counted_is_accepted(key, name):
+    g, inv, r = record({key: typed(0)})
+    write(g, inv, PASSENGER[0], [r], [count(r, key, name, 0)])
+
+
+MIXED = {"longer_10": typed(2, ">", 10), "shorter_30": typed(3, "<", 30), "shorter_6": typed(1, "<", 6)}
+PARTS = [("longer_10", "routes longer than 10 km", 2), ("shorter_30", "routes shorter than 30 km", 3),
+         ("shorter_6", "routes shorter than 6 km", 1)]
+
+
+@pytest.mark.parametrize("statement", [
+    "Every route is longer than 10 km and shorter than 30 km or shorter than 6 km among the 3 routes.",
+    "Every route is shorter than 6 km or longer than 10 km and shorter than 30 km among the 3 routes.",
+    "No route is longer than 10 km and shorter than 30 km or shorter than 6 km among the 3 routes."])
+def test_and_with_or_in_one_clause_is_left_unresolved(statement):
+    """HG-025-03: with both "and" and "or" the parts were checked one by one, so routes of 5, 20 and 25 km, which make
+    the first two statements true, gave COUNT_CONTRADICTS. No count of a part settles such a clause either way."""
+    g, inv, r = record(MIXED)
+    with pytest.raises(GraphError) as e:
+        write(g, inv, statement, [r], [count(r, k, nm, kk) for k, nm, kk in PARTS])
+    assert codes(e) == ["ABSOLUTE_WITHOUT_COUNT"]
+
+
+def test_and_or_or_alone_still_reads_as_before():
+    g, inv, r = record(MIXED)
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "Every route is longer than 10 km and shorter than 30 km among the 3 routes.", [r],
+              [count(r, k, nm, kk) for k, nm, kk in PARTS[:2]])
+    assert codes(e) == ["COUNT_CONTRADICTS"]
+    write(g, inv, "Every route is shorter than 30 km or shorter than 6 km among the 3 routes.", [r],
+          [count(r, "shorter_30", "routes shorter than 30 km", 3)])
+
+
+@pytest.mark.parametrize("k", [0, 2])
+def test_what_was_compared_is_not_what_was_counted(k):
+    """"fitting selections worth more" counts selections; "worth" says what they were compared on. The count speaks to
+    "nothing worth more fits" either way, as it did before."""
+    g, inv, r = record({"fitting_selections_worth_more": {"k": k, "n": 8, "figure": 120, "op": ">"}})
+    stmt = "The highest total value that fits within 37 kg is 120; nothing worth more fits among the 8 selections."
+    m = count(r, "fitting_selections_worth_more", "fitting selections worth more", k, 8)
+    if k:
+        with pytest.raises(GraphError) as e:
+            write(g, inv, stmt, [r], [m], scope="All 8 selections of the inventory within 37 kg.")
+        assert "COUNT_CONTRADICTS" in codes(e)
+    else:
+        write(g, inv, stmt, [r], [m], scope="All 8 selections of the inventory within 37 kg.")
+
+
+def test_a_bound_in_the_statement_is_not_what_it_is_about():
+    """"the limit is at most 49 kg" bounds the claim; it doesn't make a count of selections a count of something else."""
+    g, inv, r = record({"fitting_selections_worth_more": {"k": 3, "n": 8, "figure": 117, "op": ">"}})
+    with pytest.raises(GraphError) as e:
+        write(g, inv, "The weight limit is at most 49 kg, and the highest total value that fits within it is 117.",
+              [r], [count(r, "fitting_selections_worth_more", "fitting selections worth more", 3, 8)],
+              scope="All 8 selections of the inventory within 49 kg.")
+    assert "COUNT_CONTRADICTS" in codes(e)