hypgraph 0.7.20__tar.gz → 0.7.22__tar.gz

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

@@ -1,5 +1,57 @@
 # Changelog
 
+## 0.7.22 — 2026-11-01: a label can't move a count, every part of a claim is checked, units rule each other out
+
+Fixes from an independent audit of 0.7.21 (HG-021-01 to -04); each case below failed on 0.7.21 and is now a test.
+
+- **The result says what a count is about, not its label** (HG-021-01). 0.7.21 read a count's figure from its
+  free-text name, so renaming the count of 2 beyond 93 "worth more than 140" moved it off "the highest value is 93",
+  and the false claim went in. An instrument can now state the figure with the count
+  (`{"k": 2, "n": 1024, "figure": 93}`); that figure is the only one, a measurement whose name says another is refused
+  as `MEASUREMENT_MISMATCH`, and the figure accounts for the number in the statement. Without one, a name that
+  disagrees with its key adds a figure and never replaces one: a count that finds exceptions refutes a claim at either
+  figure, and a count of none vouches only when both are the claim's.
+- **Every absolute and every extreme in a claim is checked** (HG-021-02). A true "nothing worth more than 140 fits
+  among the 1,024 selections" ended the check, and "the highest value is 93" beside it was never looked at. One check
+  now runs per figure the absolutes are about, and the extreme is checked as well.
+- **A source that states another unit of the same kind isn't support** (HG-021-03). Only a claim that denied or
+  doubted the source's word was compared with it, so "the recorded weights are in pounds", citing the note that every
+  recorded weight is in kilograms, went in. Units of mass, length, temperature and volume, and currencies, now rule
+  each other out when the claim and the source say them of the same thing (`SOURCE_CONTRADICTS`). A clause that only
+  converts ("in kilograms, about 2.2 pounds each") or states a condition ("if the weights are pounds") asserts
+  nothing. `conduct()` counts saying the ruled-out unit again as saying the claim again.
+- **`shown_false` is not a lying rate** (HG-021-04). The `conduct()` docstring now says so: it adds up contradictions
+  by the record's own count and by a cited source, and a source can be wrong. Read `by_count`, `by_source`,
+  `corrected`, `reasserted` and `still_saying` instead.
+- Limits, unchanged: contradictions in meaning outside the unit families aren't checked; a claim that drops the
+  citation or count that would contradict it is not checked against it; `strict_claims: false` runs no claim checks;
+  and a result without a stated figure still relies on its key to say what it counted.
+
+## 0.7.21 — 2026-11-01: counts at the claim's figure, scoped negation, conduct by kind
+
+Fixes from an independent audit of 0.7.20 (HG-020-01 to -04); each case below failed on 0.7.20 and is now a test.
+
+- **A count bears on a claim only at the figure the claim names.** A count says what lies beyond one figure
+  ("fitting selections worth more than 93"). In 0.7.20, binding a count of nothing beyond 140 beside the count of 2
+  beyond 93, in either order, let "nothing worth more than 93 fits" and "the highest value is 93" in (HG-020-01); and
+  a count beyond 93 refused the true "the highest value is 95" as `COUNT_CONTRADICTS`, which `conduct()` then held
+  against its author (HG-020-02). Now a count of exceptions at the claim's own figure refutes it whatever else is bound
+  beside it, and a count at another figure neither refutes nor rescues it. A count says its figure in its name
+  ("more than 93", "above 93"); a number at the end of a key counts only when it is a figure the claim names, since it
+  may just number repeated counts (`worth_more_2` is the second count, not one beyond 2). A count that names no figure
+  is read as before.
+- **A source's "not X" negates X, not its whole sentence.** "Every recorded weight is in kilograms, not pounds" used
+  to be skipped for its "not", so it supported a claim of pounds (HG-020-03). A negation now reaches to the end of its
+  clause; "the weights were not recorded in kilograms" still asserts nothing about kilograms.
+- **Conduct says which contradiction it was, and describes behaviour, not intent** (HG-020-04). `conduct()` adds
+  `by_count` (the record's own count contradicted the claim) and `by_source` (a source the author cited as support
+  says otherwise: the citation doesn't support the claim, which is not proof it is false, since a source can be
+  wrong). `shown_false` is still their total. Its sentence names each kind, and a last word that was refused now
+  reads "contradicted by the record". The docstring no longer reads intent into it: conduct is evidence for a
+  reviewer, not a verdict on anyone.
+- Limits, unchanged and now stated: a claim that drops the citation or count that would contradict it is not checked
+  against it, and an investigation with `strict_claims: false` runs no claim checks.
+
 ## 0.7.20 — 2026-11-01: a claim the record can show false, and who keeps making it
 
 - **A claim the record's own counts show false is refused as false** (`COUNT_CONTRADICTS`). "The shortest route is

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

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

@@ -88,6 +88,32 @@ was taken from a changelog without being checked against the code.*
 > **Where that stands.** #81 is merged with green CI (17 of 17 checks); from the 0.7.20 wheel in a fresh venv the
 > suite is 450 passed, and hypswarm (118 passed) and hypmesh (37 passed) pass on it. Released as 0.7.20.
 
+> **Audit of 0.7.20 (2026-11-01), fixed for 0.7.21.** An independent audit found three false verdicts and a design
+> point, each reproduced on the 0.7.20 wheel: a zero count at another figure cancelled the count that refutes a claim
+> (HG-020-01), a count at another figure refuted a true extreme (HG-020-02), a "not" anywhere in a source sentence hid
+> what it asserts (HG-020-03), and conduct counted a claim that goes against its own citation as shown false and read
+> intent into it (HG-020-04). Counts now bear only at the figure the claim names, a negation reaches to the end of its
+> clause, and conduct reports `by_count` / `by_source` and describes behaviour, not intent. Each case is a regression
+> test written to fail on 0.7.20. Replaying 360 recorded adversarial trials gives the same standings as 0.7.20.
+>
+> **Where that stands.** #83 is merged with green CI (17 of 17 checks); from the 0.7.21 wheel in a fresh venv the
+> suite is 466 passed, and hypswarm (118 passed) and hypmesh (37 passed) pass on it. Released as 0.7.21.
+
+> **Audit of 0.7.21 (2026-11-01), fixed for 0.7.22.** A second independent audit found three ways a false claim still
+> got in, each reproduced on the 0.7.21 wheel, and a design point: renaming the count of 2 beyond 93 "worth more than
+> 140" moved it off "the highest value is 93" (HG-021-01); a true "nothing worth more than 140 fits" beside that false
+> extreme ended the check (HG-021-02); and "the recorded weights are in pounds", citing the note that they are in
+> kilograms, was never compared with it because it denied nothing (HG-021-03). `shown_false` was open to being read as
+> a lying rate (HG-021-04). A result can now state a count's figure, and a label can only widen what a count refutes;
+> every absolute and extreme in a claim is checked; units of one kind rule each other out against a cited source; the
+> conduct docstring says `shown_false` is not a lying rate. Each case is a regression test written to fail on 0.7.21.
+> Replaying 360 recorded adversarial trials (1,900 entries): 5 entries change, all the units liar's; no honest or
+> mistaken party's entry changes; two more parties still saying the false unit are named and no one new is misnamed.
+>
+> **Where that stands.** #85 is merged with green CI (17 of 17 checks); from the 0.7.22 wheel in a fresh venv the
+> suite is 482 passed, and hypswarm (118 passed) and hypmesh (37 passed) pass on it. The audit asks for a fresh
+> independent audit before anyone claims 0.7.22 resists these attack classes. Released as 0.7.22.
+
 ## 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.20 → hypgraph-0.7.22}/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.20"
+__version__ = "0.7.22"
 
 from .bundle import anchored, verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

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

@@ -154,7 +154,7 @@ def derived_numbers(bound: list[tuple[dict, dict]]) -> tuple[list[float], list[f
     prim = []
     arms = []
     for m, rv in bound:
-        plain += _nums(m) + _nums(rv)
+        plain += _nums(m) + _nums(rv) + [f for f in (stated_figure(rv),) if f is not None]
         a = _arm(rv)
         if a:
             k, n = a
@@ -199,7 +199,7 @@ def _bound(s: Snap, meas: list) -> tuple[list[tuple[dict, dict]], list[Problem]]
                                     f"{m['result']} has no value '{m['key']}'"))
             continue
         bad = False
-        for k in ("value", "k", "n"):
+        for k in ("value", "k", "n", "figure"):
             if k in m and k in rv and isinstance(m[k], (int, float)) and isinstance(rv[k], (int, float)):
                 dec = len(str(m[k]).split(".")[1]) if "." in str(m[k]) else 0
                 if round(float(rv[k]), dec) != round(float(m[k]), dec) and not (
@@ -207,6 +207,12 @@ def _bound(s: Snap, meas: list) -> tuple[list[tuple[dict, dict]], list[Problem]]
                     problems.append(Problem("MEASUREMENT_MISMATCH", f"measurement {m.get('name') or i + 1}: says "
                                             f"{k}={m[k]} but result {m['result']} has {rv[k]}"))
                     bad = True
+        said, f = _COUNT_FIGURE.search(str(m.get("name") or "")), stated_figure(rv)
+        if not bad and said and f is not None and float(said.group(1).replace(",", "")) != f:
+            problems.append(Problem("MEASUREMENT_MISMATCH", f"measurement {m.get('name')}: its name says "
+                                    f"{said.group(0).strip()}, but result {m['result']} counted '{m['key']}' against "
+                                    f"{_fmt(f)}", fix=f"name the count after {_fmt(f)}, the figure it was made against"))
+            bad = True
         if not bad:
             good.append((m, rv))
     return good, problems
@@ -253,18 +259,106 @@ def _enumerated(stmt: str, word: str) -> bool:
 _PROVEN = re.compile(r"^prov(?:es?|en|ed)$|^proof$", re.I)
 
 
+# the figure a count is about: "fitting selections worth more than 93", "routes shorter than 26 km" (or, matching a
+# figure the claim names, "worth_more_93"). A count of nothing beyond 140 says nothing about 93 (audit HG-020-01/02).
+_COUNT_FIGURE = re.compile(r"\b(?:(?:more|less|fewer|greater|higher|lower|better|worse|shorter|longer|cheaper|faster|"
+                           r"slower|larger|smaller)\s+than|above|below|over|under|beyond|exceed\w*|beat\w*)\s+\$?"
+                           r"(-?\d[\d,]*(?:\.\d+)?)", re.I)
+_KEY_FIGURE = re.compile(r"\b(?:more|less|fewer|greater|higher|lower|better|worse|shorter|longer|cheaper|faster|"
+                         r"slower|larger|smaller|above|below|over|under|beyond|exceed\w*|beat\w*)(?:\s+than)?\s+"
+                         r"(\d+(?:\.\d+)?)$", re.I)
+# the figure an absolute names in its own clause: "nothing worth more than 93 fits", "no route is shorter than 26 km"
+_CLAIM_FIGURE = re.compile(r"\b(?:more|less|fewer|greater|higher|lower|better|worse|shorter|longer|cheaper|faster|"
+                           r"slower|larger|smaller)\s+than\s+\$?(-?\d[\d,]*(?:\.\d+)?)|\b(?:above|below|beyond|"
+                           r"exceed(?:s|ing)?)\s+\$?(-?\d[\d,]*(?:\.\d+)?)", re.I)
+_SUBCLAUSE = re.compile(r",(?!\d)|[;:!?()]|\.(?!\d)|\b(?:and|but|while|whereas|although|so)\b", re.I)
+
+
+def stated_figure(rv: dict) -> float | None:
+    """The figure a count says it is about, written by the instrument beside it: {"k": 2, "n": 1024, "figure": 93} is
+    two found beyond 93."""
+    f = rv.get("figure")
+    return float(f) if isinstance(f, (int, float)) and not isinstance(f, bool) else None
+
+
+def _count_figures(m: dict, rv: dict, figs: set[float] = frozenset()) -> set[float]:
+    """Every figure a bound count could be about; empty when nothing says. A figure the result states is the only one:
+    the instrument wrote it with the count. Otherwise the name's figure ("more than 93") and the key's: a key is an
+    identifier, and the number at its end may only tell repeated counts apart ("fitting_selections_worth_more_2" is
+    the second count, not one beyond 2), so it is read only when the claim names it or the name names another. The
+    author writes the name, so a name that disagrees with the key adds a figure and never replaces one: renaming the
+    count beyond 93 "worth more than 140" no longer moves it off "the highest is 93" (audit HG-021-01)."""
+    f = stated_figure(rv)
+    if f is not None:
+        return {f}
+    out: set[float] = set()
+    hit = _COUNT_FIGURE.search(str(m.get("name") or ""))
+    if hit:
+        out.add(float(hit.group(1).replace(",", "")))
+    hit = _KEY_FIGURE.search(str(m.get("key") or "").replace("_", " "))
+    if hit and (float(hit.group(1)) in figs or out):
+        out.add(float(hit.group(1)))
+    return out
+
+
+def _absolute_figures(stmt: str, w: str) -> set[float]:
+    """The figures an absolute is about: one its own clause compares against ("nothing worth more than 93 fits"),
+    else the figures the statement's extremes name ("the highest is 93; nothing worth more fits")."""
+    figs: set[float] = set()
+    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))
+        figs |= {float((h.group(1) or h.group(2)).replace(",", "")) for h in _CLAIM_FIGURE.finditer(stmt[m.end():end])}
+    return figs or _extreme_figures(stmt)
+
+
+def _bears(m: dict, rv: dict, a: tuple[int, int], figs: set[float]) -> bool:
+    """Does this count bear on a claim about ``figs``? One about another figure doesn't, whatever it finds: a zero
+    beyond 140 can't vouch for 93, and two beyond 93 can't refute 95. When it could be about more than one figure (a
+    name that disagrees with its key), a count that finds some bears if any of them is the claim's, and a count of
+    none or all only if every one is: a label can widen what a count refutes, never what it vouches for. A count that
+    names no figure, or a claim that names none, is read as before."""
+    c = _count_figures(m, rv, figs)
+    if not c or not figs:
+        return True
+    return bool(c & figs) if 0 < a[0] < a[1] else c <= figs
+
+
+def _pinned(m: dict, rv: dict, a: tuple[int, int], figs: set[float]) -> bool:
+    """A count at the claim's own figure that finds exceptions: it refutes the claim whatever else is bound beside it."""
+    return 0 < a[0] < a[1] and bool(figs) and bool(_count_figures(m, rv, figs) & figs)
+
+
 def _absolutes(stmt: str, scope: str, body: dict, bound: list) -> list[Problem]:
+    """Every absolute in the statement, and every extreme, checked on its own: a true "nothing worth more than 140
+    fits" used to end the check, and "the highest is 93" beside it went in unexamined (audit HG-021-02)."""
     words = [w for w in L.asserted(L.ABSOLUTE, stmt) if not _enumerated(stmt, w)]
     if any(str(m.get("key") or "").lower() in ("gap", "bound") for m, _rv in bound):
         words = [w for w in words if not _PROVEN.match(w)]      # an optimum with its bound (gap 0) is proven
     words = [w for w in words if not _names_counted_set(stmt, w, bound)]
-    if not words:
-        return _superlative_contradicted(stmt, bound)
-    w = words[0]
-    arms = [(m, rv, _arm(rv)) for m, rv in bound if _arm(rv)]
+    out: list[Problem] = []
+    seen: set[frozenset] = set()
+    for w in words:                                  # one check per figure the absolutes are about
+        figs = frozenset(_absolute_figures(stmt, w))
+        if figs not in seen:
+            seen.add(figs)
+            out += [p for p in _absolute(stmt, scope, body, bound, w, words, set(figs)) 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
+
+
+def _absolute(stmt: str, scope: str, body: dict, bound: list, w: str, words: list, figs: set[float]) -> list[Problem]:
+    arms = [(m, rv, a) for m, rv in bound if (a := _arm(rv)) and _bears(m, rv, a, figs)]
+    about = L.content_words(stmt)
+    # a count at the claim's own figure that finds exceptions refutes it, whatever else is bound beside it
+    pinned = [(m, a) for m, rv, a in arms if _pinned(m, rv, a, figs)
+              and L.content_words(f"{m.get('name', '')} {m.get('key', '')}") & about]
+    if pinned:
+        m, (k, n) = max(pinned, key=lambda x: x[1][1])
+        return [_count_contradicts(stmt, w, words, m, k, n)]
     exact = [(m, rv, a) for m, rv, a in arms if a[0] in (0, a[1])]
     if not exact:
-        about = L.content_words(stmt)
         against = [(m, a) for m, _rv, a in arms if 0 < a[0] < a[1]
                    and L.content_words(f"{m.get('name', '')} {m.get('key', '')}") & about]
         if against:
@@ -411,9 +505,17 @@ def _superlative_contradicted(stmt: str, bound: list) -> list[Problem]:
     if not sup:
         return []
     about = L.content_words(stmt)
-    rel = [(m, a) for m, rv in bound if (a := _arm(rv))
+    figs = _extreme_figures(stmt)
+    rel = [(m, rv, a) for m, rv in bound if (a := _arm(rv)) and _bears(m, rv, a, figs)
            and (L.content_words(f"{m.get('name', '')} {m.get('key', '')}") & about
-                or _BEYOND.search(f"{m.get('name', '')} {m.get('key', '')}".replace("_", " ")))]
+                or _BEYOND.search(f"{m.get('name', '')} {m.get('key', '')}".replace("_", " "))
+                or stated_figure(rv) in figs)]
+    # a count beyond the extreme's own figure that finds some refutes it, whatever else is bound beside it
+    pinned = [(m, a) for m, rv, a in rel if _pinned(m, rv, a, figs) and not _qualified(stmt, *a)]
+    rel = [(m, a) for m, _rv, a in rel]
+    if pinned:
+        m, (k, n) = max(pinned, key=lambda x: x[1][1])
+        return [_count_contradicts(stmt, sup[0], sup, m, k, n)]
     if not rel or any(a[0] in (0, a[1]) for _m, a in rel):
         return []
     against = [(m, a) for m, a in rel if 0 < a[0] < a[1] and not _qualified(stmt, *a)]
@@ -487,6 +589,24 @@ def _subject_numbers(stmt: str, k: int, n: int) -> list[float]:
 _DENIAL = re.compile(r"(?:\bnot\b|\bnever\b|n't\b|\brather than\b|\binstead of\b)\s+((?:[A-Za-z]+\s+)?[A-Za-z]+)",
                      re.I)
 _PASSAGE_NEGATION = re.compile(r"\b(not|no|never|none|nor|neither|without)\b|n't\b", re.I)
+# where a negation's reach ends: "every weight is in kilograms, not pounds" negates pounds, not kilograms
+_NEGATION_ENDS = re.compile(r",(?!\d)|[;:()]|\b(?:but|while|whereas|although|though|yet|instead)\b", re.I)
+
+
+def _unnegated(sent: str) -> str:
+    """A source sentence less what its negations reach: from each "not" / "never" / "no" ... to the end of its clause.
+    "Every recorded weight is in kilograms, not pounds" still asserts kilograms; "the weights were not recorded in
+    kilograms" asserts nothing about kilograms. (0.7.20 dropped any sentence with a negation in it, so a source saying
+    "kilograms, not pounds" supported a claim of pounds; audit HG-020-03.)"""
+    out, i = [], 0
+    for m in _PASSAGE_NEGATION.finditer(sent):
+        if m.start() < i:
+            continue
+        out.append(sent[i:m.start()])
+        end = _NEGATION_ENDS.search(sent, m.end())
+        i = end.start() if end else len(sent)
+    out.append(sent[i:])
+    return "".join(out)
 
 
 def denied_words(stmt: str) -> set[str]:
@@ -548,31 +668,109 @@ def _asserted_words(sent: str) -> list[str]:
 
 
 def _affirmed_in(passage: str, stem: str) -> str:
-    """The sentence of ``passage`` that asserts a word with this stem without negating anything, or ''."""
+    """The sentence of ``passage`` that asserts a word with this stem outside the reach of any negation, or ''."""
     for sent in re.split(r"(?<=[.!?;])\s+", passage or ""):
-        if stem in L.content_words(sent) and not _PASSAGE_NEGATION.search(sent):
+        if stem in L.content_words(_unnegated(sent)):
             return sent.strip()
     return ""
 
 
 def _doubted_in(passage: str, doubted: set[str]) -> tuple[list[str], str] | None:
-    """The words a plain (un-negated) sentence of ``passage`` asserts ("every weight ... is in kilograms") that the
-    statement doubts, and the sentence. Doubting a source's subject ("whether the container is available") is not
-    doubting what it says of it ("the container takes at most 36 kg")."""
+    """The words a sentence of ``passage`` asserts outside the reach of any negation ("every weight ... is in
+    kilograms, not pounds" asserts kilograms) that the statement doubts, and the sentence. Doubting a source's subject
+    ("whether the container is available") is not doubting what it says of it ("the container takes at most 36 kg")."""
     if not doubted:
         return None
     for sent in re.split(r"(?<=[.!?;])\s+", passage or ""):
-        if _PASSAGE_NEGATION.search(sent):
-            continue
-        hit = list(dict.fromkeys(w for w in _asserted_words(sent) if w in doubted))
+        hit = list(dict.fromkeys(w for w in _asserted_words(_unnegated(sent)) if w in doubted))
         if hit:
             return hit, sent.strip()
     return None
 
 
+# units of one kind rule each other out: weights recorded in kilograms are not recorded in pounds. Only units and
+# currencies, where the alternatives are known; a claim that contradicts a source in meaning outside these families
+# isn't caught here (audit HG-021-03).
+_UNIT_FAMILIES = {
+    "mass": {"kilogram": "kilogram kilograms kilo kilos kg kgs", "gram": "gram grams", "milligram": "milligram "
+             "milligrams mg", "tonne": "tonne tonnes ton tons", "pound": "pound pounds lb lbs",
+             "ounce": "ounce ounces oz"},
+    "length": {"metre": "metre metres meter meters", "kilometre": "kilometre kilometres kilometer kilometers km kms",
+               "centimetre": "centimetre centimetres centimeter centimeters cm", "millimetre": "millimetre millimetres "
+               "millimeter millimeters mm", "mile": "mile miles", "yard": "yard yards", "foot": "foot feet ft",
+               "inch": "inch inches"},
+    "temperature": {"celsius": "celsius centigrade", "fahrenheit": "fahrenheit", "kelvin": "kelvin"},
+    "volume": {"litre": "litre litres liter liters", "millilitre": "millilitre millilitres milliliter milliliters ml",
+               "gallon": "gallon gallons", "pint": "pint pints", "quart": "quart quarts"},
+    "currency": {"dollar": "dollar dollars usd", "euro": "euro euros eur", "pound": "pound pounds gbp sterling",
+                 "yen": "yen jpy", "yuan": "yuan renminbi cny", "rupee": "rupee rupees inr", "franc": "franc francs chf",
+                 "peso": "peso pesos"},
+}
+_UNIT_OF = {}
+for _fam, _units in _UNIT_FAMILIES.items():
+    for _canon, _words in _units.items():
+        for _w in _words.split():
+            _UNIT_OF.setdefault(_w, set()).add((_fam, _canon))
+_UNIT_CLAUSE = re.compile(r",(?!\d)|[;:()]|\.(?!\d)|\b(?:and|but|while|whereas|although|though|because|since|so)\b",
+                          re.I)
+
+
+def _plural(canon: str) -> str:
+    return {"foot": "feet", "inch": "inches", "celsius": "celsius", "fahrenheit": "fahrenheit", "kelvin": "kelvin",
+            "yen": "yen", "yuan": "yuan"}.get(canon, canon + "s")
+
+
+def _units_in(text: str) -> set[tuple[str, str]]:
+    return {u for w in re.findall(r"[a-z]+", (text or "").lower()) for u in _UNIT_OF.get(w, ())}
+
+
+_CONDITIONAL = re.compile(r"\b(?:if|whether|unless|suppos\w*|assum\w*|were they|had they)\b", re.I)
+
+
+def _unit_assertions(text: str) -> list[tuple[set[str], set[tuple[str, str]], str]]:
+    """(subject words, units asserted of it, clause) for each clause with a copula, outside the reach of negation:
+    "the recorded weights are in pounds" says pounds of the recorded weights. A condition ("if the weights are
+    pounds") asserts nothing."""
+    out = []
+    for c in _UNIT_CLAUSE.split(_unnegated(text or "")):
+        cop = _ASSERTS.search(c)
+        if cop and not _CONDITIONAL.search(c[:cop.start()]) and (units := _units_in(c[cop.end():])):
+            out.append((L.content_words(c[:cop.start()]), units, c.strip()))
+    return out
+
+
+def asserted_units(stmt: str) -> set[str]:
+    """The units (canonical names) a statement asserts of something: refusals.carried reads them to tell a unit
+    contradiction said again from a correction."""
+    return {canon for _subj, units, _c in _unit_assertions(stmt) for _fam, canon in units}
+
+
+def _other_unit(passage: str, stmt: str) -> tuple[str, str, str] | None:
+    """(the statement's unit, the source's, the source sentence) when a sentence of ``passage`` says the statement's
+    subject is in another unit of the same kind, and no clause of the statement about that subject says the source's
+    unit too (a clause that only converts, "about 2.2 pounds each", asserts nothing; "kilograms, not pounds" is a
+    denial, checked above)."""
+    claimed = _unit_assertions(stmt)
+    if not claimed:
+        return None
+    for sent in re.split(r"(?<=[.!?;])\s+", passage or ""):
+        clean = _unnegated(sent)
+        cop = list(_ASSERTS.finditer(clean))
+        if not cop:
+            continue
+        subj, said = L.content_words(clean[:cop[-1].start()]), _units_in(clean[cop[-1].end():])
+        about = [units for csubj, units, _c in claimed if csubj & subj]
+        also = {u for units in about for u in units}
+        for fam, canon in sorted(also):
+            theirs = {c for f, c in said if f == fam}
+            if theirs and canon not in theirs and not {(fam, c) for c in theirs} & also:
+                return canon, sorted(theirs)[0], sent.strip()
+    return None
+
+
 def _source_contradicts(s: Snap, stmt: str, support: list[str]) -> list[Problem]:
     denied, doubted = denied_words(stmt), doubted_words(stmt)
-    if not denied and not doubted:
+    if not denied and not doubted and not _unit_assertions(stmt):
         return []
     for src in support:
         n = s.nodes.get(src)
@@ -600,6 +798,16 @@ def _source_contradicts(s: Snap, stmt: str, support: list[str]) -> list[Problem]
                                 "says the opposite isn't support: correct the statement, or link the source as a "
                                 "challenge",
                                 fix="correct the statement, or link that source as a challenge", words=[stem])]
+        other = _other_unit(passage, stmt)
+        if other:
+            ours, theirs, sent = other
+            cite = str(n["body"].get("citation") or "").strip()
+            label = cite[:80] if cite else (n.get("code") or src)
+            return [Problem("SOURCE_CONTRADICTS",
+                            f"the statement says {_plural(ours)}, but a source it links as support ({label}) says "
+                            f"{_plural(theirs)}: \"{sent[:200]}\". One quantity isn't in two units of one kind, so that source isn't "
+                            "support: correct the statement, or link the source as a challenge",
+                            fix="correct the statement, or link that source as a challenge", words=[f"unit:{ours}"])]
     return []
 
 

{hypgraph-0.7.20 → hypgraph-0.7.22}/src/hypgraph/refusals.py

@@ -27,11 +27,13 @@ chain, separate from the record's events (verify() on the record is unchanged; v
                    says the false part and doesn't fix it either: the author moved off it. Logged once each time
                    the author moves off it. ``ref`` is the refusal it leaves behind.
 
-conduct() is the per-author view of those: how often the record showed an author's claim false, how often the
+conduct() is the per-author view of those: how often the record contradicted an author's claim, how often the
 author corrected it, how often it said the same thing again — and where it stands now: whether its LAST word on
-each claim shown false still says it. An honest mistake gets corrected when the contradiction is shown; still saying
-it at the end, after being shown, is the mark of a party arguing in bad faith. A party that repeated itself once
-and then moved off the claim is counted as having said it again, but not as still saying it.
+each contradicted claim still says it. A party that repeated itself once and then moved off the claim is counted as
+having said it again, but not as still saying it. It keeps the two kinds apart: the record's own count (``by_count``)
+and a source the author cited as support that says otherwise (``by_source``) — the second shows the citation doesn't
+support the claim, not that the claim is false, since a source can be wrong. Conduct describes what an author did
+after being shown, not why: it is evidence for a reviewer to weigh, not a verdict on anyone's intent.
 
 report() turns it into the numbers worth watching: overclaims caught per author, how many were fixed and how many
 abandoned, which rules fire most — "your agents tried to say 'never' 14 times this week; 11 came back honest".
@@ -132,7 +134,7 @@ def carried(problems: list[dict], statement: str) -> bool:
     carried when one clause holds every figure it named (the '=…' words) again AND still asserts an extreme or an
     absolute about them ("the highest value is 93", "nothing beats 93"): mentioning the old figure in a correction
     ("1 of 82 routes is shorter than 26 km") is not saying it again. A source contradiction is carried when the
-    statement still denies or doubts the same word."""
+    statement still denies or doubts the same word, or still says the unit the source ruled out."""
     from . import checks
     denied = checks.denied_words(statement or "")
     clauses = [c for c in _CLAUSE.split(statement or "") if c.strip()]
@@ -140,6 +142,9 @@ def carried(problems: list[dict], statement: str) -> bool:
         words = [str(w) for w in p.get("words") or []]
         if p.get("code") == "SOURCE_CONTRADICTS" and set(words) & (denied | checks.doubted_words(statement or "")):
             return True
+        units = {w[5:] for w in words if w.startswith("unit:")}           # the unit a source ruled out
+        if p.get("code") == "SOURCE_CONTRADICTS" and units & checks.asserted_units(statement or ""):
+            return True
         figs = [float(w[1:]) for w in words if w.startswith("=") and w[1:].replace(".", "", 1).isdigit()]
         if p.get("code") != "COUNT_CONTRADICTS" or not figs:
             continue
@@ -333,14 +338,17 @@ def rows(g: "Graph", inv: str = "", author: str = "", since: str = "", limit: in
 
 
 def conduct(g: "Graph", inv: str = "", author: str = "") -> dict:
-    """Per author: how often the record showed a claim of theirs false (its own count, or a source they cited, says
+    """Per author: how often the record contradicted a claim of theirs (its own count, or a source they cited, says
     the opposite), how often they then corrected it, and how often they said the same thing again.
-    {author: {"shown_false", "corrected", "reasserted", "open", "still_saying", "moved_off", "sentence"}}. A
+    {author: {"shown_false", "by_count", "by_source", "corrected", "reasserted", "open", "still_saying", "moved_off",
+    "ends_false", "sentence"}}. ``shown_false`` is every claim contradicted, ``by_count`` / ``by_source`` how many of
+    them the record's own count or a cited source contradicted (one claim can be both). A
     re-assertion that was itself refused is not counted as a new time shown false. ``still_saying``: claims shown false
     whose author's last word on them (its last fix, repeat or move away, in log order) says them again;
     ``moved_off``: claims it last moved away from without a fix; ``ends_false``: the author's last write was itself
     shown false or said a contradicted claim again (a fresh false claim at the end counts, which ``still_saying``,
-    being per claim, can't see)."""
+    being per claim, can't see). ``shown_false`` is not a rate of lying: it adds up two kinds of evidence, and a cited
+    source can itself be wrong. Read the parts, and what the author did next, not the total."""
     con = g._connect()
     q, args = "SELECT id, kind, author, ref, codes, detail FROM refusal_log WHERE 1=1", []
     for col, val in (("inv", inv), ("author", author)):
@@ -359,6 +367,7 @@ def conduct(g: "Graph", inv: str = "", author: str = "") -> dict:
                 repeats.add(r)
     shown = {rid: a for rid, kind, a, _r, codes, _d in rows
              if kind == "refused" and rid not in repeats and set(json.loads(codes or "[]")) & set(CONTRADICTIONS)}
+    shown_codes = {rid: set(json.loads(codes or "[]")) for rid, _k, _a, _r, codes, _d in rows if rid in shown}
     root = {}                                       # a repeat's own refusal → the refusal it repeated
     for _id, kind, _a, ref, _c, det in rows:
         if kind == "reasserted" and ref:
@@ -379,9 +388,11 @@ def conduct(g: "Graph", inv: str = "", author: str = "") -> dict:
                 last[r] = kind
     out: dict[str, dict] = {}
     for rid, a in shown.items():
-        o = out.setdefault(a, {"shown_false": 0, "corrected": 0, "reasserted": 0, "open": 0, "still_saying": 0,
-                               "moved_off": 0})
+        o = out.setdefault(a, {"shown_false": 0, "by_count": 0, "by_source": 0, "corrected": 0, "reasserted": 0,
+                               "open": 0, "still_saying": 0, "moved_off": 0})
         o["shown_false"] += 1
+        o["by_count"] += "COUNT_CONTRADICTS" in shown_codes[rid]
+        o["by_source"] += "SOURCE_CONTRADICTS" in shown_codes[rid]
         fixed = any(k == "fixed" and r == rid for _i, k, _a, r, _c, _d in rows)
         again = sum(1 for _i, k, _a, r, _c, _d in rows if k == "reasserted" and r == rid)
         o["corrected"] += fixed
@@ -409,8 +420,12 @@ def conduct(g: "Graph", inv: str = "", author: str = "") -> dict:
         o["ends_false"] = any(k == "reasserted" or (k == "refused" and set(json.loads(c or "[]")) & set(CONTRADICTIONS))
                               for k, c in rs) and not _accepted_after(con, a, inv, key)
     for a, o in out.items():
-        n = o["shown_false"]
-        o["sentence"] = (f"the record showed a claim of this author's false {n} time{'s' * (n != 1)}; "
+        c, s_ = o["by_count"], o["by_source"]
+        shown = "; ".join(
+            ([f"the record's own count contradicted a claim of this author's {c} time{'s' * (c != 1)}"] if c else [])
+            + ([f"{s_} claim{'s' * (s_ != 1)} of this author's went against a source it cited as support"]
+               if s_ else []))
+        o["sentence"] = (shown + "; "
                          + (f"the author said it again {o['reasserted']} time{'s' * (o['reasserted'] != 1)} after "
                             "being shown" if o["reasserted"] else "the author did not say it again")
                          # "never corrected" only beside a repeat: dropping a claim for a different one is no repeat
@@ -418,7 +433,7 @@ def conduct(g: "Graph", inv: str = "", author: str = "") -> dict:
                             if o["corrected"] else ", and never corrected it"
                             if o["reasserted"] and (o["still_saying"] or o["ends_false"]) else "")
                          + ("; its last word still says it" if o["still_saying"] else
-                            "; its last word was shown false" if o["ends_false"] else
+                            "; its last word was contradicted by the record" if o["ends_false"] else
                             "; its last word no longer says it" if o["reasserted"] else ""))
     return out