hypgraph 0.8.0__tar.gz → 0.8.1__tar.gz

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

@@ -1,5 +1,26 @@
 # Changelog
 
+## 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.1}/PKG-INFO

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

@@ -234,6 +234,21 @@ 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.
+
 ## 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.1}/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.1}/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.1"
 
 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.1}/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.1}/src/hypgraph/checks.py

@@ -1841,11 +1841,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 +1883,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.1}/tests/test_assertions.py

@@ -7,7 +7,9 @@ is decided by sets on the number line and population paths. Invariants: a verdic
 never on the sentence around them; a true atom never lends anything to a false one; a count is whole."""
 import itertools
 import json
+import math
 import random
+from fractions import Fraction
 
 import pytest
 
@@ -75,16 +77,17 @@ def brute(q, op_a, f_a, op_e, f_e, k, n, kk=None):
 @pytest.mark.parametrize("op_a", A.OPS)
 @pytest.mark.parametrize("op_e", A.OPS)
 @pytest.mark.parametrize("f_a", [20, 26, 30])
-def test_the_interval_logic_never_decides_what_enumeration_leaves_open(q, op_a, op_e, f_a):
-    """Sound: a supported or contradicted verdict is what every consistent world says. (Unresolved may be returned
-    where enumeration could decide — the logic is conservative — but never the other way round.)"""
+def test_the_interval_logic_decides_exactly_what_enumeration_decides(q, op_a, op_e, f_a):
+    """Sound and complete over one population: supported or contradicted exactly when every consistent world agrees,
+    unresolved exactly when they differ. (0.8.0 left 'exactly' open unless its set was the counted one or its
+    complement; it is now decided from bounds — HG-080.)"""
     n = 3
     for k in range(n + 1):
-        kw = {"k": 1} if q == "exactly" else {}
-        a = atom(q, op_a, f_a, **kw)
-        got = A._decide(a, A.count_fields(cnt(k, 26, op_e, n))[0])[0]
-        want = brute(q, op_a, f_a, op_e, 26, k, n, kw.get("k"))
-        assert got == "unresolved" or got == want, (q, op_a, f_a, op_e, k, got, want)
+        for kk in (range(n + 1) if q == "exactly" else [None]):
+            kw = {"k": kk} if q == "exactly" else {}
+            got = A._decide(atom(q, op_a, f_a, **kw), A.count_fields(cnt(k, 26, op_e, n))[0])[0]
+            want = brute(q, op_a, f_a, op_e, 26, k, n, kk)
+            assert got == want, (q, op_a, f_a, op_e, k, kk, got, want)
 
 
 @pytest.mark.parametrize("q", ["none", "all", "some"])
@@ -388,3 +391,119 @@ def test_a_drafted_lie_is_still_refused():
             "measurements": [{"result": r, "key": "over_26"}]}
     d = A.draft(g.snapshot(), body, inv)
     assert [v["verdict"] for v in A.verify(g.snapshot(), {**body, "asserts": d}, inv)] == ["contradicted"]
+
+
+# ── HG-080-01: exact at any magnitude ───────────────────────────────────────────────────────────────────────────
+
+TRICKY = [10**16, 10**18, 10**24, 1e18, 10**18 + 1, -10**18, 2**53, 2**53 + 1, 5e-324, 0, -0.0, 1.0,
+          math.nextafter(1.0, 2.0), 26, 26.0]
+
+
+def exact_subset(a, b):
+    """The reference: the probe method in exact rational arithmetic, where a figure ± 1 and a midpoint are always new
+    points (in floats, above 2**53 they are the figure itself)."""
+    fa, fb = Fraction(a[1]), Fraction(b[1])
+    pts = sorted({fa, fb})
+    probes = pts + [pts[0] - 1, pts[-1] + 1] + [(x + y) / 2 for x, y in zip(pts, pts[1:])]
+    return all(A.holds(x, b[0], fb) for x in probes if A.holds(x, a[0], fa))
+
+
+@pytest.mark.parametrize("fa", TRICKY)
+@pytest.mark.parametrize("fb", TRICKY)
+def test_containment_is_exact_at_any_magnitude(fa, fb):
+    for oa in A.OPS:
+        for ob in A.OPS:
+            assert A.subset((oa, fa), (ob, fb)) == exact_subset((oa, fa), (ob, fb)), (oa, fa, ob, fb)
+
+
+@pytest.mark.parametrize("f", [10**16, 10**18, 1e18, 10**24])
+def test_a_large_figure_decides_as_a_small_one(f):
+    def e(k, op):
+        return A.count_fields(cnt(k, f, op))[0]
+    assert not A.subset((">", f), ("<=", f)) and not A.same_set((">", f), ("<", f))
+    assert A._decide(atom("none", "<", f, n=4), e(0, ">"))[0] == "unresolved"       # 0 above F says nothing below
+    assert A._decide(atom("exactly", "<", f, n=4, k=4), e(4, ">"))[0] == "contradicted"
+    assert A._decide(atom("none", ">", f, n=4), e(0, ">"))[0] == "supported"
+    assert A._decide(atom("some", ">=", f), e(1, ">"))[0] == "supported"
+
+
+def test_one_past_a_large_figure_is_another_figure():
+    """10**18 + 1 is not 1e18, though float() makes them one: nothing over 10**18 + 1 leaves room above 10**18."""
+    assert A._decide(atom("none", ">", 10**18, n=4), A.count_fields(cnt(0, 10**18 + 1))[0])[0] == "unresolved"
+    assert A._decide(atom("none", ">", 10**18 + 1, n=4), A.count_fields(cnt(0, 10**18))[0])[0] == "supported"
+
+
+def test_a_large_figure_through_the_write_gate():
+    values = {"over": cnt(0, 10**18, ">", unit=None)}
+    codes = write(values, "No route is shorter than 1000000000000000000 among the 4 routes.",
+                  [atom("none", "<", 10**18, unit=None, n=4)], ["over"])
+    assert "ASSERTION_UNRESOLVED" in codes, codes
+    values = {"over": cnt(4, 10**18, ">", unit=None)}
+    codes = write(values, "Exactly 4 of the 4 routes are shorter than 1000000000000000000.",
+                  [atom("exactly", "<", 10**18, unit=None, n=4, k=4)], ["over"])
+    assert "ASSERTION_CONTRADICTED" in codes, codes
+
+
+def test_a_figure_renders_as_it_is():
+    assert A.stats_fmt(10**18 + 1) == "1000000000000000001" and A.stats_fmt(26.0) == "26"
+    assert A.stats_fmt(math.nextafter(1.0, 2.0)) == "1.0000000000000002"
+    assert A.key(atom("none", figure=10**18)) != A.key(atom("none", figure=10**18 + 1))
+    assert A.key(atom("none", figure=26)) == A.key(atom("none", figure=26.0))
+
+
+# ── HG-080-02: a unit is one only within its kind ───────────────────────────────────────────────────────────────
+
+@pytest.mark.parametrize("a,b,same", [
+    ("lb", "lbs", True), ("GBP", "sterling", True), ("km", "kilometres", True), ("pounds", "pound", True),
+    ("widgets", "widgets", True), (None, None, True), (None, "", True),
+    ("lb", "GBP", False), ("lbs", "gbp", False), ("lb", "sterling", False),   # mass is never currency
+    ("pound", "lb", False), ("pound", "GBP", False),                            # "pound" could be either
+    ("km", "miles", False), ("km", None, False),
+])
+def test_units_are_one_only_within_their_kind(a, b, same):
+    assert A.same_unit(a, b) is same and A.same_unit(b, a) is same, (a, b)
+
+
+def test_a_currency_count_cannot_back_a_mass_claim():
+    values = {"over": cnt(0, 40, ">", population="shipment", property="quantity", unit="GBP")}
+    a = atom("none", ">", 40, population="shipment", property="quantity", unit="lb", n=4)
+    v, field, _why = A._decide(a, A.count_fields(values["over"])[0])
+    assert (v, field) == ("unresolved", "unit")
+    codes = write(values, "No shipment weighs more than 40 lb among the 4 shipments.", [a], ["over"])
+    assert "ASSERTION_UNRESOLVED" in codes, codes
+
+
+def test_an_ambiguous_unit_says_what_it_could_be():
+    v, field, why = A._decide(atom("none", unit="pound", n=4), A.count_fields(cnt(0, unit="lb"))[0])
+    assert (v, field) == ("unresolved", "unit") and "could be currency or mass" in why, why
+
+
+# ── an extreme stated as a value is two atoms ───────────────────────────────────────────────────────────────────
+
+EXTREME = {"over_26": cnt(0), "at_least_26": cnt(1, op=">=")}
+BOTH = [atom("none", n=4), atom("some", ">=", m=1)]
+
+
+def test_an_extreme_stated_as_a_value_needs_both_atoms():
+    stmt = "The longest of the 4 routes is 26 km."
+    assert write(EXTREME, stmt, BOTH, ["over_26", "at_least_26"]) == []
+    for one in (BOTH[:1], BOTH[1:]):
+        codes = write(EXTREME, stmt, one, ["over_26", "at_least_26"])
+        assert "ASSERTION_MISSING" in codes, (one, codes)
+
+
+def test_an_extreme_stated_as_a_bound_needs_one_atom():
+    values = {"at_least_40": cnt(1, 40, ">=", property="time", unit="minutes")}
+    assert write(values, "The slowest of the 4 routes took at least 40 minutes.",
+                 [atom("some", ">=", 40, property="time", unit="minutes")], ["at_least_40"]) == []
+
+
+@pytest.mark.parametrize("part,needed", [
+    ("The longest of the 4 routes is 26 km.", 2), ("The highest score was 93.", 2),
+    ("The longest route, at 26 km, is the only one above 20 km.", 2),
+    ("The slowest of the 4 routes took at least 40 minutes.", 1), ("The highest of all 4 scores is at most 93.", 1),
+    ("No route is longer than 26 km.", 1),
+])
+def test_how_many_atoms_a_part_asks_for(part, needed):
+    from hypgraph import checks as C
+    assert C.atoms_needed(part) == needed