hypgraph 0.8.0__tar.gz → 0.8.2__tar.gz

{hypgraph-0.8.0 → hypgraph-0.8.2}/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 0.8.2 — 2026-11-01: an extreme that quotes its own counterexample; a disputed answer
+
+- **A quoted counterexample no longer excuses an extreme.** A stated count used to exempt an extreme whenever its
+  clause said "k of n ... than", meant for a count about a figure of the statement's own ("the shortest is 21 km; 1 of
+  77 are shorter than 26 km"). It also exempted the count at the extreme's own figure, so "the shortest route is 30 km,
+  since 1 of 77 are shorter than 30 km" was accepted. The count is now an exception to the extreme whenever its figure,
+  on the result or in the sentence, is the extreme's own.
+- **Two readings that exemption had hidden.** "The highest ... is therefore not 125" is a denial (an adverb between
+  the copula and "not"), and a bound in the extreme's own direction ("the shortest is at most 30 km", "91 or more") is
+  not a claim that the figure is the extreme. A bound the other way ("the shortest is at least 30 km") still claims it.
+- Replayed on 1,900 recorded claim writes: 5 change, all now refused. Four are an extreme stated beside the count
+  that shows it false. One is a retraction worded as the claim ("the highest is 80, but this is not correct: 3 of
+  1,024 are worth more"). Who the record names as still saying something false is unchanged or better on every set.
+- **`hypgraph demo dispute`: a disputed answer.** A teaching record in which two parties answer one question from the
+  same road register. Ada makes an honest mistake, the record refuses it (`COUNT_CONTRADICTS`) and she corrects it.
+  Mallory cites the register's units note for a claim it contradicts, is refused twice (`SOURCE_CONTRADICTS`) and files
+  it without the note. An independent reviewer checks one claim and fails the other, so the Evidence view shows one
+  answer checked and one contested, and `Graph.conduct()` names who kept saying it. It is also on the website
+  (`examples/dispute/`, in every site language) and in the README. `hypgraph demo` with no name still builds Broad
+  Street.
+
+## 0.8.1 — 2026-11-01: exact figures, units within their kind
+
+An independent audit of 0.8.0 found two defects in the typed checks, both confirmed on the published wheel.
+
+- **Exact figures (HG-080-01).** Containment of two conditions was decided by probing at each figure ± 1 and the
+  midpoints, in floats. Above 2**53 a figure + 1 is the figure, so x > 1e18 looked inside x <= 1e18, and a count of 0
+  above 1e18 supported "none below 1e18". Containment is now decided on the pieces the two figures cut the line into,
+  with no arithmetic on them, and figures keep their exact value (10**18 + 1 is not 1e18; it renders as itself).
+- **Units within their kind (HG-080-02).** The unit table's kind was dropped, so `lb` (mass) matched `GBP` and
+  `sterling` (currency) through the shared name "pound". A unit is now its (kind, unit) readings: `lb` = `lbs` and
+  `GBP` = `sterling` still, never across kinds, and an ambiguous `pound` matches only another `pound`; the refusal says
+  what it could be and asks for `lb` or `GBP`.
+- **`exactly` decided from bounds.** It was left unresolved unless its set was the counted one or its complement:
+  4 of 4 above F now contradicts "exactly 4 below F". Over one population every verdict now equals enumeration of the
+  consistent worlds (sound and complete), and the test checks that.
+- **An extreme stated as a value is two atoms.** In a typed investigation "the longest of the 4 routes is 26 km"
+  needs both "none above 26" and "some at 26 or more"; one of them is refused (`ASSERTION_MISSING`). An extreme stated
+  as a bound ("the slowest took at least 40 minutes") needs one.
+- Tests: containment against exact rational probes over large, adjacent, subnormal and signed-zero figures; the audit's
+  cases through `_decide` and the write gate; units; extremes. The audit's own test file passes (13 of 13).
+
 ## 0.8.0 — 2026-11-01: typed claim assertions
 
 Eight independent audits (HG-020 → HG-028) found the same class of failure, each time in a new wording: to decide

{hypgraph-0.8.0 → hypgraph-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.8.0
+Version: 0.8.2
 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/
@@ -136,6 +136,34 @@ CL1 — withdrawn claim · …
   ⚠ 2 nodes rest on CL1: 1 decision (D1); 1 claim (CL2) — now AT RISK
 ```
 
+## Calling out a bad answer
+
+Two agents answer one question from the same road register. One makes an honest mistake and the other lies. The
+record tells them apart, and nobody has to label anyone:
+
+<p align="center"><a href="https://hypgraph.com/examples/dispute/"><picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://hypgraph.com/assets/readme/dispute-dark.png">
+  <img src="https://hypgraph.com/assets/readme/dispute-light.png" width="880" alt="The Evidence view of a disputed answer: Ada's claim that the shortest route is 29 km is checked, Mallory's claim that the register is in miles is contested, above the two route counts the instrument filed and the seven register items they rest on">
+</picture></a></p>
+<p align="center"><sub>Standing derived from the record: one answer checked, the other contested. <code>hypgraph demo dispute</code> builds it; <a href="https://hypgraph.com/examples/dispute/">open it live</a>.</sub></p>
+
+- **Ada** says the shortest route is 30 km. The instrument counted 1 of the 4 routes as shorter, so the record refuses
+  it (`COUNT_CONTRADICTS`). She corrects it to 29 km, which the count backs.
+- **Mallory** says the register is in miles, and cites the register's own units note as support. The note says
+  kilometres, so the record refuses it (`SOURCE_CONTRADICTS`). She says it again and is refused again.
+
+The record can't catch every lie by itself: once Mallory stops citing the note, her claim goes in. But it keeps what
+she was shown. The reviewer fails her claim against the note, and the conduct log (`hypgraph refusals`,
+`Graph.conduct()`) says who corrected what they were shown and who kept saying it:
+
+```text
+$ hypgraph demo dispute
+…
+What the record says of each author:
+  ada        the record's own count contradicted a claim of this author's 1 time; the author did not say it again, and corrected it 1 time
+  mallory    1 claim of this author's went against a source it cited as support; the author said it again 2 times after being shown, and never corrected it; its last word still says it
+```
+
 ## Derived, never asserted
 
 Nothing in the record is ever *set* as known. How well each claim is known is **derived on every read**:

{hypgraph-0.8.0 → hypgraph-0.8.2}/README.md

@@ -104,6 +104,34 @@ CL1 — withdrawn claim · …
   ⚠ 2 nodes rest on CL1: 1 decision (D1); 1 claim (CL2) — now AT RISK
 ```
 
+## Calling out a bad answer
+
+Two agents answer one question from the same road register. One makes an honest mistake and the other lies. The
+record tells them apart, and nobody has to label anyone:
+
+<p align="center"><a href="https://hypgraph.com/examples/dispute/"><picture>
+  <source media="(prefers-color-scheme: dark)" srcset="https://hypgraph.com/assets/readme/dispute-dark.png">
+  <img src="https://hypgraph.com/assets/readme/dispute-light.png" width="880" alt="The Evidence view of a disputed answer: Ada's claim that the shortest route is 29 km is checked, Mallory's claim that the register is in miles is contested, above the two route counts the instrument filed and the seven register items they rest on">
+</picture></a></p>
+<p align="center"><sub>Standing derived from the record: one answer checked, the other contested. <code>hypgraph demo dispute</code> builds it; <a href="https://hypgraph.com/examples/dispute/">open it live</a>.</sub></p>
+
+- **Ada** says the shortest route is 30 km. The instrument counted 1 of the 4 routes as shorter, so the record refuses
+  it (`COUNT_CONTRADICTS`). She corrects it to 29 km, which the count backs.
+- **Mallory** says the register is in miles, and cites the register's own units note as support. The note says
+  kilometres, so the record refuses it (`SOURCE_CONTRADICTS`). She says it again and is refused again.
+
+The record can't catch every lie by itself: once Mallory stops citing the note, her claim goes in. But it keeps what
+she was shown. The reviewer fails her claim against the note, and the conduct log (`hypgraph refusals`,
+`Graph.conduct()`) says who corrected what they were shown and who kept saying it:
+
+```text
+$ hypgraph demo dispute
+…
+What the record says of each author:
+  ada        the record's own count contradicted a claim of this author's 1 time; the author did not say it again, and corrected it 1 time
+  mallory    1 claim of this author's went against a source it cited as support; the author said it again 2 times after being shown, and never corrected it; its last word still says it
+```
+
 ## Derived, never asserted
 
 Nothing in the record is ever *set* as known. How well each claim is known is **derived on every read**:

{hypgraph-0.8.0 → hypgraph-0.8.2}/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.8.0 (2026-11-01)
+## Status at 0.8.2 (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.8.0 → hypgraph-0.8.2}/docs/RELEASE-READINESS.md

@@ -234,6 +234,28 @@ was taken from a changelog without being checked against the code.*
 > verified, and the record shows the atoms, not the sentence, as what it checked. Replaying the 1,900 recorded
 > adversarial entries changes none. #102 is merged with green CI (17 of 17 checks). Released as 0.8.0.
 
+> **Audit of 0.8.0 (2026-11-01).** The first audit of the typed layer found its architecture sound (GO for a
+> controlled typed-claims pilot) and two narrow defects in its helpers, both reproduced on the published wheel (its
+> test file: 9 failed, the 4 controls passed; the wheel's SHA-256 matched the audit's). Containment was probed in
+> floats at figure ± 1, which above 2**53 is the figure itself, so opposite conditions at 1e18 looked equal and an
+> unsupported "none below 1e18" was supported (HG-080-01). And units dropped their kind, so `lb` matched `GBP` through
+> the shared name "pound" (HG-080-02). Containment is now decided exactly on the pieces of the line, with figures kept
+> as given; a unit is its (kind, unit) readings. Two related gaps closed with them: `exactly` was left open unless its
+> set was the counted one (now decided from bounds, and every verdict equals enumeration over one population), and an
+> extreme stated as a value now needs both its atoms.
+>
+> **Where that stands.** The boundary the audit names stays: prose is matched to atoms by reading words, so a missed
+> part leaves prose unverified, never an atom verified; integrations should consume `asserts` and their verdicts, not
+> the statement. Untyped mode keeps its documented limits. #104 is merged with green CI (17 of 17 checks). Released as
+> 0.8.1.
+
+> **After 0.8.1 (2026-11-01).** The frozen word checks were changed once, for a soundness gap rather than a new
+> wording: a stated count exempted an extreme even when the count was at the extreme's own figure, so an extreme that
+> quoted its own counterexample was accepted. The exemption now holds only for a count about another figure; an adverb
+> before "not" and a bound in the extreme's own direction are read as what they are. Replaying the 1,900 recorded
+> claim writes changes 5, all now refused (4 lies, 1 retraction worded as the claim). #106 is merged with green CI.
+> Released as 0.8.2, with the `dispute` demo (#107).
+
 ## 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.8.0 → hypgraph-0.8.2}/docs/spec.md

@@ -290,22 +290,29 @@ smallest detectable difference uses 80% power at two-sided α = 0.05.
 
 **Typed claims.** An atom (§2) is decided by its bound count alone; no words are read. Let S_e = {x : x op_e f_e} (what
 was counted, k of n inside it, n − k outside) and S_a = {x : x op_a f_a} (what is asserted); P_e and P_a the
-populations. The property must equal the count's and the unit match it (spellings of one unit are one unit; nothing is
-converted); a stated `n` must equal the count's.
+populations. The property must equal the count's and the unit match it: spellings of one unit are one unit within one
+kind of unit (`lb` = `lbs`, `GBP` = `sterling`, never `lb` = `GBP`), a spelling that could be two kinds (`pound`:
+mass or currency) matches only another that could be the same two, and nothing is converted. A stated `n` must equal
+the count's. Figures are compared exactly, as given (an int or a float, at any magnitude), on the pieces of the line
+the two figures cut it into — never by arithmetic on them.
 
 - `none` S_a: **supported** when a side of the count with 0 inside it contains S_a and P_a lies within P_e;
   **contradicted** when a side with more than 0 lies inside S_a and P_e lies within P_a.
 - `some` S_a: supported when a side with more than 0 lies inside S_a and P_e within P_a; contradicted when a side with
   0 contains S_a and P_a lies within P_e.
-- `all` S_a is `none` of the complement of S_a. `exactly` k needs the same population and the same set (or its
-  complement, counted n − k), then compares k.
+- `all` S_a is `none` of the complement of S_a.
+- `exactly` k needs the same population. A side of the count lying inside S_a puts at least its count in S_a; a side
+  containing S_a, at most its count. k at both bounds is **supported**, k outside them **contradicted**.
+
+Over one population these verdicts are complete as well as sound: supported or contradicted exactly when every set of
+values consistent with the count agrees.
 - Anything else is **unresolved**, and names the field that blocked it.
 
 | Code | Refused when |
 |---|---|
 | `ASSERTION_CONTRADICTED` | an atom is false by its count. The refusal log tracks it like a count contradiction (§8). |
 | `ASSERTION_UNRESOLVED` | an atom its count can't settle: another property or unit, a population neither within nor containing the count's, a condition the count's doesn't decide, an untyped count, a malformed atom. |
-| `ASSERTION_MISSING` | in a `typed_claims` investigation, the statement has more parts that assert an absolute, an extreme or a count than the claim has atoms. Detection reads words only to ask for atoms; a missed word leaves prose unverified, never an atom verified. The refusal proposes atoms drafted from the statement and the claim's typed counts, which are checked like any other once written. |
+| `ASSERTION_MISSING` | in a `typed_claims` investigation, the statement's parts that assert an absolute, an extreme or a count need more atoms than the claim has: one each, and two for an extreme stated as a value ("the longest is 26 km": none above, some at or above). Detection reads words only to ask for atoms; a missed word leaves prose unverified, never an atom verified. The refusal proposes atoms drafted from the statement and the claim's typed counts, which are checked like any other once written. |
 
 Atoms are checked in every investigation that has them. In a `typed_claims` investigation the word interpretation
 stands down: a measurement's name and key are not read for what was counted, and rule 5 (absolutes, with the

{hypgraph-0.8.0 → hypgraph-0.8.2}/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.8.0"
+__version__ = "0.8.2"
 
 from .bundle import anchored, verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.8.0 → hypgraph-0.8.2}/src/hypgraph/assertions.py

@@ -18,7 +18,9 @@ steered one of those inferences. Here the instrument types what it counted and t
   population  a path: ``route/passenger`` lies within ``route``, so a count of 0 over every route also settles
               "no passenger route"; a count of the passenger routes says nothing of the cargo routes.
   property    an id, compared for equality ("length" is not "speed").
-  unit        compared for equality, spellings of one unit read as one ("km" = "kilometres"); never converted.
+  unit        compared for equality, spellings of one unit read as one ("km" = "kilometres") within one kind of unit:
+              "lb" is mass and "GBP" currency, never the same; "pound", which could be either, matches only
+              another spelling that could be either. Never converted.
   n           optional: the population's size as the claim states it; must be the count's n.
 
 Each atom is decided on its own, by sets on the number line — S_e = {x : x op_e figure_e} (what was counted) and
@@ -28,7 +30,13 @@ S_a = {x : x op_a figure_a} (what is asserted) — and the paths. A count of k i
               contradicted when a count above 0 is over a set inside S_a and a population inside the atom's
   some S_a    the mirror: a count above 0 inside S_a supports it, a count of 0 containing S_a contradicts it
   all S_a     none of the complement of S_a
-  exactly     the same set and the same population, then k compared
+  exactly     the same population; a count over a set inside S_a puts at least that many in it, a count over a
+              set containing S_a at most that many: k inside those bounds, at both ends supported, outside them
+              contradicted (4 of 4 above F puts at most 0 below it, so "exactly 4 below F" is false)
+
+Figures are compared exactly, at any magnitude: containment is decided on the pieces of the number line the two
+figures cut it into (the figures themselves and the open intervals between), with no arithmetic on the figures — a
+probe at figure + 1 is the figure itself above 2**53, which made x > 1e18 look inside x <= 1e18 (HG-080-01).
 
 Anything else is unresolved, and the verdict names the field that blocked it. One count can back two atoms only if
 each checks out against it on its own, so a true absolute can't lend anything to a false one (HG-028-01), and "all"
@@ -76,29 +84,56 @@ def prop(p) -> str | None:
 
 
 def _unit(u) -> frozenset | None:
-    """A unit as the set of names it could be ("km" → {kilometre}); None when there's none."""
+    """A unit as the (kind, unit) pairs it could be ("km" → {(length, kilometre)}, "pound" → {(mass, pound),
+    (currency, pound)}); an unknown spelling is itself. None when there's none."""
     if u is None or (isinstance(u, str) and not u.strip()):
         return None
     from .checks import _UNIT_OF                           # one table of unit spellings, shared with the word checks
     w = str(u).strip().lower()
-    return frozenset(c for _f, c in _UNIT_OF.get(w, ())) or frozenset({w})
+    return frozenset(_UNIT_OF.get(w, ())) or frozenset({("", w)})
 
 
 def same_unit(a, b) -> bool:
-    ua, ub = _unit(a), _unit(b)
-    return (ua is None and ub is None) or (ua is not None and ub is not None and bool(ua & ub))
+    """One unit: every reading of one is a reading of the other. "lb" = "lbs" and "GBP" = "sterling", but "lb" is
+    never "GBP" (HG-080-02), and an ambiguous "pound" is neither of them."""
+    return _unit(a) == _unit(b)
+
+
+def ambiguous(u) -> list[str]:
+    """The kinds of unit an ambiguous spelling could be ("pound": currency, mass); [] when it is one unit."""
+    kinds = sorted({k for k, _c in _unit(u) or ()})
+    return kinds if len(kinds) > 1 else []
 
 
 def holds(x: float, op: str, f: float) -> bool:
     return {"<": x < f, "<=": x <= f, "=": x == f, "!=": x != f, ">=": x >= f, ">": x > f}[op]
 
 
+def _pieces(*figures) -> list[tuple]:
+    """The number line cut at the figures: each figure as a point ("pt", x) and the open intervals between and beyond
+    them ("iv", lo, hi), None for an infinite end. Figures are compared as given (Python compares ints and floats
+    exactly); nothing is added to or averaged from them."""
+    pts = sorted(set(figures))
+    out: list[tuple] = [("iv", None, pts[0])]
+    for x, y in zip(pts, pts[1:]):
+        out += [("pt", x), ("iv", x, y)]
+    return out + [("pt", pts[-1]), ("iv", pts[-1], None)]
+
+
+def _inside(piece: tuple, op: str, f) -> bool:
+    """Is a piece of the line inside {x : x op f}? f is one of the cuts, so an open interval lies wholly below or
+    wholly above it, and which side decides."""
+    if piece[0] == "pt":
+        return holds(piece[1], op, f)
+    _iv, _lo, hi = piece
+    below = hi is not None and hi <= f
+    return op in ("<", "<=", "!=") if below else op in (">", ">=", "!=")
+
+
 def subset(a: tuple, b: tuple) -> bool:
-    """Is {x : x a[0] a[1]} inside {x : x b[0] b[1]}? Both sets are unions of intervals with ends at the two figures,
-    so membership is constant on each piece between them: checking one point per piece decides it."""
-    pts = sorted({float(a[1]), float(b[1])})
-    probes = pts + [pts[0] - 1, pts[-1] + 1] + [(x + y) / 2 for x, y in zip(pts, pts[1:])]
-    return all(holds(x, *b) for x in probes if holds(x, *a))
+    """Is {x : x a[0] a[1]} inside {x : x b[0] b[1]}? Both sets are unions of the pieces the two figures cut the line
+    into, so it is decided piece by piece, exactly, at any magnitude."""
+    return all(_inside(p, *b) for p in _pieces(a[1], b[1]) if _inside(p, *a))
 
 
 def same_set(a: tuple, b: tuple) -> bool:
@@ -122,7 +157,7 @@ def count_fields(rv) -> tuple[dict | None, str]:
     pop = path(rv["population"])
     if pop is None:
         return None, "the count's population is not a path (route/passenger)"
-    return {"k": int(k), "n": int(n), "op": rv["op"], "figure": float(rv["figure"]), "population": pop,
+    return {"k": int(k), "n": int(n), "op": rv["op"], "figure": rv["figure"], "population": pop,
             "property": prop(rv["property"]), "unit": rv.get("unit")}, ""
 
 
@@ -171,9 +206,18 @@ def _cond(a: dict) -> str:
     return f"{a['property']} {SHOW_OP.get(a['op'], a['op'])} {fig}{u}"
 
 
+def whole_form(f):
+    """A figure with its exact value, an integral float as an int (26.0 → 26, 1e18 → 10**18): 26 and 26.0 are one
+    figure. (Not ``f.is_integer()`` on an int — that is Python 3.12+.)"""
+    return f if isinstance(f, int) else int(f) if float(f).is_integer() else f
+
+
 def stats_fmt(v) -> str:
+    """A figure as it is: ints whole, floats exact (repr round-trips), so a rendered figure never hides a difference."""
+    if isinstance(v, int):
+        return str(v)
     v = float(v)
-    return str(int(v)) if v.is_integer() else f"{v:g}"
+    return str(int(v)) if v.is_integer() and abs(v) < 1e15 else repr(v)
 
 
 def render(a: dict) -> str:
@@ -213,8 +257,11 @@ def _decide(a: dict, e: dict) -> tuple[str, str, str]:
         return "unresolved", "property", (f"the count is of {e['property']}, the assertion is about "
                                           f"{prop(a['property'])}")
     if not same_unit(a.get("unit"), e.get("unit")):
+        amb = next(((u, ambiguous(u)) for u in (a.get("unit"), e.get("unit")) if ambiguous(u)), None)
         return "unresolved", "unit", (f"the count is in {e.get('unit') or 'no unit'}, the assertion in "
-                                      f"{a.get('unit') or 'no unit'}: state the figure in the count's unit")
+                                      f"{a.get('unit') or 'no unit'}: state the figure in the count's unit"
+                                      + (f"; '{amb[0]}' could be {' or '.join(amb[1])}, so name the unit "
+                                         "unambiguously (lb, GBP)" if amb else ""))
     if not (within(pa, pe) or within(pe, pa)):
         return "unresolved", "population", (f"the count is of {_pop(pe)}, the assertion is about {_pop(pa)}: "
                                             "neither lies within the other")
@@ -225,7 +272,7 @@ def _decide(a: dict, e: dict) -> tuple[str, str, str]:
                                    f"{_pop(pe)} ({e['n']}) doesn't give")
     # what was counted, both ways: k inside S_e and n - k outside it
     sides = [((e["op"], e["figure"]), e["k"]), ((COMPLEMENT[e["op"]], e["figure"]), e["n"] - e["k"])]
-    q, t = a["quantifier"], (a["op"], float(a["figure"]))
+    q, t = a["quantifier"], (a["op"], a["figure"])
     got = _settle(q, t, sides, pa, pe, a)
     if got:
         return got
@@ -242,11 +289,18 @@ def _settle(q: str, t: tuple, sides: list, pa: tuple, pe: tuple, a: dict) -> tup
     if q == "exactly":
         if pa != pe:
             return None
+        lo, hi = 0, sum(c for _side, c in sides)
         for side, c in sides:
-            if same_set(t, side):
-                ok = int(a["k"]) == c
-                return ("supported" if ok else "contradicted", "" if ok else "k",
-                        f"the count finds {c}" + ("" if ok else f", not {int(a['k'])}"))
+            if subset(side, t):                  # everything counted there is in the atom's set
+                lo = max(lo, c)
+            if subset(t, side):                  # the atom's set lies inside what was counted there
+                hi = min(hi, c)
+        want = int(a["k"])
+        found = f"the count finds {lo}" if lo == hi else f"the count puts {lo} to {hi} there"
+        if lo == hi == want:
+            return "supported", "", found
+        if want < lo or want > hi:
+            return "contradicted", "k", f"{found}, not {want}"
         return None
     neg = "that don't" if q == "all" else "that do"
     if q == "all":                               # everything meets it: nothing meets its complement
@@ -308,8 +362,10 @@ def key(a) -> str:
     if atom_shape(a, None)[0]:
         return json.dumps(a, sort_keys=True, default=str)[:300]
     u = _unit(a.get("unit"))
+    f = a["figure"]
+    fig = whole_form(f)                                                          # 26 and 26.0 are one figure, exactly
     return json.dumps([a["quantifier"], "/".join(path(a["population"]) or ()), prop(a["property"]), a["op"],
-                       float(a["figure"]), sorted(u) if u else None, a.get("n"), a.get("k")], default=str)
+                       fig, sorted(u) if u else None, a.get("n"), a.get("k")], default=str)
 
 
 def numbers(body: dict) -> list[float]:
@@ -375,7 +431,7 @@ def draft(s: Snap, body: dict, inv: str = "") -> list[dict]:
             pool = [(i, e) for i, e in typed if e["n"] == n]
             for i, e in [x for x in pool if x[1]["figure"] in figs] or pool:
                 add({"quantifier": "exactly", "population": _pop(e["population"]), "property": e["property"],
-                     "op": e["op"], "figure": int(e["figure"]) if e["figure"].is_integer() else e["figure"],
+                     "op": e["op"], "figure": whole_form(e["figure"]),
                      "k": k, "n": n, "measurement": i}, e)
     return out[:6]
 

{hypgraph-0.8.0 → hypgraph-0.8.2}/src/hypgraph/checks.py

@@ -955,22 +955,34 @@ def claimed_extremes(stmt: str) -> list[str]:
                               if not _enumerated(stmt, w) and not _names_stated_count(stmt, w)]
 
 
+# an adverb between the copula and its negation: "the highest ... is therefore not 125"
+_ADVERB = r"(?:(?:therefore|thus|hence|then|so|also|still|\w+ly)\s+)?"
 # the extreme's own predicate denied after it, in its clause: "the highest total value ... is not 130"
-_DENIED_EXTREME = re.compile(r"\b(?:is|are|was|were)\s+(?:not|no longer|never)\b|\b(?:isn't|aren't|wasn't|weren't)\b|"
+_DENIED_EXTREME = re.compile(r"\b(?:is|are|was|were)\s+" + _ADVERB + r"(?:not|no longer|never)\b|"
+                             r"\b(?:isn't|aren't|wasn't|weren't)\b|"
                              # or said to lie beyond a figure: "the true maximum is higher than 98"
                              r"\b(?:is|are|was|were|lies)\s+(?:\w+\s+)?(?:higher|lower|greater|larger|smaller|more|less|"
                              r"above|below|over|under|shorter|longer|beyond)\b", re.I)
 # or denied before it: "120 is not the highest total value", "isn't the shortest"
-_DENIED_BEFORE = re.compile(r"(?:\b(?:is|are|was|were)\s+(?:not|no longer|never)|\b(?:isn't|aren't|wasn't|weren't))"
+_DENIED_BEFORE = re.compile(r"(?:\b(?:is|are|was|were)\s+" + _ADVERB + r"(?:not|no longer|never)|"
+                            r"\b(?:isn't|aren't|wasn't|weren't))"
                             r"\s+(?:the\s+|a\s+|an\s+)?(?:true\s+|real\s+|actual\s+)?$", re.I)
 _COPULA = re.compile(r"\b(?:is|are|was|were|isn't|aren't|wasn't|weren't|lies)\b", re.I)
 
 
-def _denied(after: str) -> bool:
+def _denied(after: str, w: str = "") -> bool:
     """Does the extreme's own predicate — the first copula after it — deny it or put it beyond a figure? Only that
-    one: "the highest value is 98 ..., so the true maximum is higher" still claims 98."""
+    one: "the highest value is 98 ..., so the true maximum is higher" still claims 98. A bound in the extreme's own
+    direction is beyond its figure too: "the highest value is at least 91" (or "91 or more") says the true maximum is
+    91 or above, which what lies beyond 91 doesn't contradict; "the highest is at most 91" still claims a figure."""
     cop = _COPULA.search(after)
-    return bool(cop and _DENIED_EXTREME.match(after, cop.start()))
+    if not cop:
+        return False
+    if _DENIED_EXTREME.match(after, cop.start()):
+        return True
+    own = {s for _a, s, _strict in _comparisons_in(w)}
+    pred = after[cop.end():].split(",")[0]
+    return bool(own) and any(not strict and s in own for _a, s, strict in _comparisons_in(pred))
 
 
 # a count named for what lies beyond a figure ("fitting selections worth more", "shorter routes connecting") is about
@@ -988,7 +1000,7 @@ def _extremes(stmt: str) -> list[str]:
         for m in re.finditer(r"\b" + re.escape(w) + r"\b", stmt, re.I):
             end = next((x.start() for x in _CLAUSE.finditer(stmt, m.end())), len(stmt))
             start = max((x.end() for x in _CLAUSE.finditer(stmt, 0, m.start())), default=0)
-            if (not _denied(stmt[m.end():end]) and not _DENIED_BEFORE.search(stmt[start:m.start()])
+            if (not _denied(stmt[m.end():end], w) and not _DENIED_BEFORE.search(stmt[start:m.start()])
                     and re.search(r"\d", stmt[start:end])):
                 out.append(w)
                 break
@@ -1011,11 +1023,23 @@ def _count_contradicts(stmt: str, w: str, words: list, m: dict, k: int, n: int)
                    words=words + [f"={_fmt(v)}" for v in _subject_numbers(stmt, k, n)])
 
 
-def _qualified(stmt: str, k: int, n: int) -> bool:
+_THAN_FIGURE = re.compile(r"\bthan\s+\$?(-?\d[\d,]*(?:\.\d+)?)", re.I)
+
+
+def _qualified(stmt: str, k: int, n: int, figs: frozenset = frozenset(), rv: dict | None = None) -> bool:
     """Does the statement give this count about a figure of its own ("1 of 61 routes are shorter than 26 km")?
-    Then it's a count of something beyond that figure, not of exceptions to the extreme it claims."""
+    Then it's a count of something beyond that figure, not of exceptions to the extreme it claims. Not when the
+    figure is the extreme's own: "the shortest route is 30 km, since 1 of 77 are shorter than 30 km" states the very
+    count that shows it false, and quoting the counterexample doesn't make an extreme true."""
+    if figs and rv is not None and stated_figure(rv) in figs:
+        return False
     forms = {f"{k} of {n}", f"{k:,} of {n:,}"}
-    return any(any(f in c for f in forms) and re.search(r"\bthan\b", c) for c in _CLAUSE.split(stmt))
+    for c in _CLAUSE.split(stmt):
+        if any(f in c for f in forms) and re.search(r"\bthan\b", c):
+            said = {float(x.replace(",", "")) for x in _THAN_FIGURE.findall(c)}
+            if not (said & set(figs)):
+                return True
+    return False
 
 
 def _superlative_contradicted(stmt: str, bound: list) -> list[Problem]:
@@ -1032,7 +1056,7 @@ def _superlative_contradicted(stmt: str, bound: list) -> list[Problem]:
                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)
-               and not (role == "refute" and _qualified(stmt, *a))]
+               and not (role == "refute" and _qualified(stmt, *a, figs, rv))]
         # 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, role in rel if role == "refute" and _pinned(m, rv, set(figs))]
         if pinned:
@@ -1061,7 +1085,7 @@ def _extreme_claims(stmt: str) -> list[tuple[str, frozenset]]:
             end = next((x.start() for x in _CLAUSE.finditer(stmt, m.end())), len(stmt))
             start = max((x.end() for x in _CLAUSE.finditer(stmt, 0, m.start())), default=0)
             after = stmt[m.end():end]
-            if _denied(after) or _DENIED_BEFORE.search(stmt[start:m.start()]):
+            if _denied(after, w) or _DENIED_BEFORE.search(stmt[start:m.start()]):
                 continue
             cop = _COPULA.search(after)
             fig = _FIGURE.match(after, cop.end()) if cop else None
@@ -1841,11 +1865,28 @@ def asserting_parts(stmt: str) -> list[str]:
         if L.interrogative(p):
             continue
         quantified = any(_clause_comparisons(m.group("rest"), after_no=True) for m in _QUANT_CMP.finditer(p))
-        if L.asserted(L.ABSOLUTE, p) or _extremes(p) or _STATED_COUNT.search(p) or quantified or                 _NO_NOUN_VERB.search(p):
+        if L.asserted(L.ABSOLUTE, p) or _extremes(p) or _STATED_COUNT.search(p) or quantified or _NO_NOUN_VERB.search(p):
             out.append(p.strip())
     return out
 
 
+_STATED_FIGURE = re.compile(r"(?<![\w.])\d[\d,]*(?:\.\d+)?")
+_POPULATION_SIZE = re.compile(r"\b(?:of|among|across|between|from|in|all)\s+(?:the\s+|all\s+|its\s+|these\s+|those\s+)?"
+                              r"(\d[\d,]*)\b(?!\s*(?:%|percent|per\s*cent))", re.I)
+
+
+def atoms_needed(part: str) -> int:
+    """How many atoms a part asks for: an extreme stated as a value ("the longest of the 4 routes is 26 km") is two —
+    nothing above 26 and something at 26 or more; a figure it states only as a bound ("the slowest took at least 40
+    minutes") is one. Over-counting asks for one more atom; it never marks one verified."""
+    if not _extremes(part):
+        return 1
+    bounds = {f for f, _c in _clause_comparisons(part)}
+    sizes = {m.start(1) for m in _POPULATION_SIZE.finditer(part)}            # "of the 4 routes" is who, not a figure
+    stated = {float(m.group(0).replace(",", "")) for m in _STATED_FIGURE.finditer(part) if m.start() not in sizes}
+    return 2 if stated - bounds else 1
+
+
 def assertion_issues(s: Snap, body: dict, inv: str, stmt: str, typed: bool) -> list[Problem]:
     """The claim's atoms checked against their counts, and — in a typed investigation — whether the statement asserts
     more than its atoms do."""
@@ -1866,13 +1907,17 @@ def assertion_issues(s: Snap, body: dict, inv: str, stmt: str, typed: bool) -> l
                                    f"{v['field']}", words=[v["field"]]))
     if typed:
         parts = asserting_parts(stmt)
-        if len(parts) > len(atoms):
+        needed = sum(atoms_needed(p) for p in parts)
+        if needed > len(atoms):
             proposed = A.draft(s, body, inv) if not atoms else []
             hint = (" Proposed from the statement and its typed counts — check each before using it: "
                     + json.dumps(proposed, separators=(",", ":"))[:900]) if proposed else ""
             out.append(Problem("ASSERTION_MISSING", f"this investigation checks claims as typed assertions: the "
                                f"statement asserts {len(parts)} thing{'s' * (len(parts) != 1)} — "
-                               + "; ".join(f"'{p[:80]}'" for p in parts[:4]) + f" — and the claim gives {len(atoms)} "
+                               + "; ".join(f"'{p[:80]}'" for p in parts[:4]) + f" — {needed} atom"
+                               + "s" * (needed != 1) + " in all" + (" (an extreme stated as a value is two: none "
+                               "above it, some at it or beyond)" if needed > len(parts) else "")
+                               + f", and the claim gives {len(atoms)} "
                                "atom" + "s" * (len(atoms) != 1) + ". Add an atom for each to asserts: {quantifier "
                                "(none | all | some | exactly), population, property, op, figure, unit, n, "
                                "measurement}." + hint, fix="add an atom to asserts for each thing the statement "

{hypgraph-0.8.0 → hypgraph-0.8.2}/src/hypgraph/cli.py

@@ -2,6 +2,7 @@
 hypgraph — the command line.
 
     hypgraph demo                       build the Broad Street (1854) teaching investigation into ./research.hypgraph
+    hypgraph demo dispute               an honest mistake and a lie: the record checks one and contests the other
     hypgraph serve                      open the HypGraph UI on http://127.0.0.1:8765
     hypgraph init "Plant growth" --objective "…" --reviewers ada,lin
     hypgraph add hypothesis statement="Blue light grows cress faster." predictions='["taller after 7 days"]'
@@ -351,19 +352,27 @@ def cmd_import(args) -> int:
 
 
 def cmd_demo(args) -> int:
-    from .demos import broad_street
+    import importlib
+
+    from .demos import DEMOS
+    demo = importlib.import_module(DEMOS[args.name])
     if Path(args.db).exists():
-        raise GraphError(f"{args.db} exists — choose another file: hypgraph demo --db broad-street.hypgraph")
-    g, inv, story = broad_street.build(path=args.db)
+        raise GraphError(f"{args.db} exists — choose another file: hypgraph demo {args.name} --db {args.name}.hypgraph")
+    g, inv, story = demo.build(path=args.db)
+    conduct = g.conduct(inv) if args.name == "dispute" else {}
     if args.json:
-        _out(args, {"db": g.path, "inv": inv, "story": story})
+        _out(args, {"db": g.path, "inv": inv, "story": story, **({"conduct": conduct} if conduct else {})})
         return 0
     for s in story:
         print(f"{s['at']}  {s['actor']:<10} {s['text']}")
         if "refused" in s:
             print("            ✗ the record refused it:\n              " +
                   s["refused"].replace("\n", "\n              "))
-    print(f"\nBuilt {broad_street.TITLE!r} into {g.path}.\nExplore it:  hypgraph --db {args.db} serve"
+    if conduct:
+        print("\nWhat the record says of each author:")
+        for who, row in conduct.items():
+            print(f"  {who:<10} {row['sentence']}")
+    print(f"\nBuilt {demo.TITLE!r} into {g.path}.\nExplore it:  hypgraph --db {args.db} serve"
           f"   ·   hypgraph --db {args.db} report")
     return 0
 
@@ -553,7 +562,9 @@ def build_parser() -> argparse.ArgumentParser:
                         "outside the hash chain")
     s = cmd("import", cmd_import, "rebuild a graph file from a complete bundle")
     s.add_argument("bundle")
-    cmd("demo", cmd_demo, "build the Broad Street (1854) teaching investigation")
+    s = cmd("demo", cmd_demo, "build a teaching investigation: Broad Street (1854), or a disputed answer")
+    s.add_argument("name", nargs="?", default="broad-street", choices=["broad-street", "dispute"],
+                   help="broad-street (default), or dispute: an honest mistake and a lie, told apart by the record")
     cmd("schema", cmd_schema, "the node types and relations")
     s = cmd("refusals", cmd_refusals, "the overclaims the record caught: per author, per rule, fixed or open")
     s.add_argument("--inv", default="")

{hypgraph-0.8.0 → hypgraph-0.8.2}/src/hypgraph/demos/__init__.py

@@ -1,3 +1,3 @@
 """Teaching investigations that ship with HypGraph. ``hypgraph demo`` builds one into a file you can explore."""
 
-DEMOS = {"broad-street": "hypgraph.demos.broad_street"}
+DEMOS = {"broad-street": "hypgraph.demos.broad_street", "dispute": "hypgraph.demos.dispute"}