hypgraph 0.7.1__tar.gz → 0.7.3__tar.gz

{hypgraph-0.7.1 → hypgraph-0.7.3}/CHANGELOG.md

@@ -1,5 +1,74 @@
 # Changelog
 
+## 0.7.3 — 2026-10-28: the refusal log sees everything — results, shape, links — and reads a link as the relation that joins
+
+- **A link is read as the relation that joins.** A relation that can't join its two types, where one relation says
+  the same thing between them, is applied as that relation with a note, like a link turned round: an experiment
+  that "supports" a hypothesis *tests* it; a run that "uses" an experiment *executes* it; a result, experiment or
+  decision that "answers" a question is *part of* it; a claim or result that "uses" or "rests on" an artifact is
+  *derived from* it; a decision that "supports" a claim is *based on* it (`schema.TRANSLATE`). An experiment may
+  `uses` the artifact it is designed on. A link refused on its pair is matched as fixed by the link that then
+  lands between the same nodes. Read off 23 `LINK_NOT_ALLOWED` refusals in nine runs: every hint named the
+  relation, 3 were taken; 19 of the 23 pairs now go through.
+- **Shape refusals are logged, coded, and say where the thing goes.** A sixteen-challenge sweep's run logs held
+  217 refusals for a field, an option or a link the schema doesn't have, against the 79 overclaims its refusal
+  logs held — the larger friction stream, and invisible to the log, the report and the replay. Now `clean_body`
+  and the link check raise a `GraphError` whose `problems` carry a code (`SHAPE_UNKNOWN_FIELD`,
+  `SHAPE_NOT_AN_OPTION`, `SHAPE_MISSING_FIELD`, `SHAPE_TOO_LONG`, `SHAPE_TOO_SHORT`, `SHAPE_WRONG_TYPE`,
+  `LINK_NOT_ALLOWED`, `LINK_UNKNOWN_RELATION`, `LINK_NO_NODE`) and a fix; `create`, `revise` and `link` log the
+  refusal with the body (`detail.type` `shape` / `link`) before raising it; `refusal_report` counts them apart under
+  `shape`; `replay_refusals` skips them. The three messages the sweep hit most now say where the thing goes: `code`
+  on a result belongs to the run (`code=[…]`, `produced` → the result); an experiment's `expected` goes on its
+  `tests` link (`data: {expected: …}`); and `outcome must be one of …` explains each option. An option written as
+  a leading word and a sentence ("negative — no outcome remains significant after correction", "H1 confirmed: the
+  setting loses its edge") is read as the word, the sentence kept as the evidence note; a leading "fail" stays
+  refused as ambiguous (negative if the code ran and showed the opposite, failed if it didn't run). Plural and
+  result-kind words on a claim's `kind` (`findings`, `computed`) map to `finding`. Read off the 17 outcome bodies
+  the new log captured in the first runs on the branch: 9 were whole sentences with no option word (refused, now
+  with the fix), 8 began with one.
+- **The refusal log treats results like claims.** A refused result is logged in full (its summary as the statement,
+  `RESULT_RESTATES` included), the author's next accepted result that says the same thing — by its words, or by
+  carrying at least half of the refused result's value keys again — fixes it (`fixes_refusals`, and the report's
+  *fixed* column, which showed 0 for every result code), and `replay_refusals` runs results through the value and
+  profile result checks as their author, claims through the profile checks too (an `EDGE_WITHOUT_TRIALS` refusal
+  used to replay as `passes`), and counts `RESULT_RESTATES` and typed-node refusals as skipped instead of replaying
+  a decision's choice as a claim. Found replaying 846 refusals from the challenge studies.
+## 0.7.2 — 2026-10-28: the honest sentences the rules were refusing, and a nominal effect can't hide its correction
+
+- **Honest sentences the rules were refusing.** Read off every refusal logged in 96 records of the challenge studies
+  (846 refusals; each fix replayed on all of them):
+  - absolutes over a set the sentence counts ("cases 1-7 all pass", "none of these 49 rows", "all other 19
+    outcomes"), "almost all", an interval "entirely below zero", "distinguishable from zero", "cannot be used /
+    asserted / ruled out", and "proven" beside a bound gap or bound, are not generalisations and pass;
+  - "no difference remains significant after correction" denies a test, it is not an exclusion that needs power;
+    "the interval excludes zero" is interval language;
+  - a p-value is found by its key's tokens (`welch_two_sided_p`, `raw_p_steps_k`, `steps_k_p`), not only by a `p_`
+    prefix, so "significant" beside such a field is tested rather than refused;
+  - a key written beside its value ("n_sig_holm = 0 of 20") is not `KEY_FOR_NUMBER`; "two-sided" and a date are not
+    unbound numbers;
+  - a result value's `k` and `n` must be numbers (`VALUE_NOT_A_NUMBER`): `{"k": "40/50", "n": "rank 1 of 20"}` is a
+    label in a count's clothes, and it crashed a run downstream;
+  - the instrument's re-execution of a run (what the code printed) is not asked for `feasible` beside an objective
+    or fees beside a return — the original result was; a benchmark's return (buy-and-hold, flat) is not a return
+    the strategy earned, and `BACKTEST_WITHOUT_COSTS` now names the fields it took as returns.
+- **`UNCORRECTED_EFFECT` reads its qualifier beside the effect word.** "Uncorrected" counts within 20 words of
+  "changes" / "differs", in the same sentence — not anywhere in it. A 70-word finding "The supplement changes
+  steps_k … while dropping its uncorrected p < 0.05 claim" had passed on the word's presence alone.
+- **A nominal effect can't hide its correction in the scope.** New code `UNCORRECTED_EFFECT`: a finding that says an
+  outcome changed, differs or is significant, while a live result in the same investigation holds that outcome's
+  corrected p-value (Holm, Bonferroni, FDR, …) at or above 0.05 or a count of 0 outcomes surviving correction, is
+  refused unless the sentence says the test is uncorrected ("differs at uncorrected p < 0.05"), or it binds a
+  corrected value and names the correction — or it is filed as a lead. The
+  refusal quotes the result and field. "Not significant after Holm correction (Holm p = 0.25)" beside a bound
+  nominal p of 0.012 is read against the corrected p, not refused as `SIGNIFICANCE_CONTRADICTED`. Found in a
+  20-outcome trial study, where two of twelve runs settled "the supplement changes steps_k" as a checked finding,
+  hedged only in the scope field, while the same record said nothing survived correction.
+- **The record's own bookkeeping decision isn't a position.** `accept_work` settles an order with a decision
+  whose text quotes the order's objective and that rests on the claims that met its predicates. Under trading, a
+  kind-less decision with position words in its text and `based_on` links counted as a position, so settling an
+  order on "should the desk take a paper position?" was refused for want of a stop (POSITION_WITHOUT_STOP) and the
+  run crashed as it settled. The decision now carries `kind: accepted`; a real position still needs its stop.
+
 ## 0.7.1 — 2026-10-27: a computed answer needs its code, and opposed answers keep a question open
 
 - **A computation nobody can re-run doesn't settle a computational question.** The optimization workflow's

{hypgraph-0.7.1 → hypgraph-0.7.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.7.1
+Version: 0.7.3
 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/
@@ -76,6 +76,7 @@ holds every claim to that:
 | "significantly better", counts 812/1,000 vs 800/1,000 | `SIGNIFICANCE_NOT_SHOWN` | the record runs the test: p = 0.5 |
 | "prompt format has no effect" | `EXCLUSION_WITHOUT_POWER` | at 2,000 items a 3.6-point effect would usually go unseen |
 | "longer prompts cause the gain" | `CAUSAL_WITHOUT_INTERVENTION` | no experiment intervened |
+| "the supplement changes steps_k", p = 0.012, while the record's Holm p is 0.25 | `UNCORRECTED_EFFECT` | one of 20 outcomes; the claim's own record says it doesn't survive correction |
 | "outperforms the baseline", no numbers | `COMPARATIVE_WITHOUT_COMPARISON` | only one side was measured |
 
 Every refusal has a stable code, the arithmetic, and the sentence that *would* be honest, so an agent can repair a

{hypgraph-0.7.1 → hypgraph-0.7.3}/README.md

@@ -44,6 +44,7 @@ holds every claim to that:
 | "significantly better", counts 812/1,000 vs 800/1,000 | `SIGNIFICANCE_NOT_SHOWN` | the record runs the test: p = 0.5 |
 | "prompt format has no effect" | `EXCLUSION_WITHOUT_POWER` | at 2,000 items a 3.6-point effect would usually go unseen |
 | "longer prompts cause the gain" | `CAUSAL_WITHOUT_INTERVENTION` | no experiment intervened |
+| "the supplement changes steps_k", p = 0.012, while the record's Holm p is 0.25 | `UNCORRECTED_EFFECT` | one of 20 outcomes; the claim's own record says it doesn't survive correction |
 | "outperforms the baseline", no numbers | `COMPARATIVE_WITHOUT_COMPARISON` | only one side was measured |
 
 Every refusal has a stable code, the arithmetic, and the sentence that *would* be honest, so an agent can repair a

{hypgraph-0.7.1 → hypgraph-0.7.3}/docs/spec.md

@@ -41,7 +41,7 @@ correction is a new row, never an edited one.
 | `tests` | experiment | claim, hypothesis | an experiment tests a hypothesis or claim (data.expected: what it should show if true) |
 | `executes` | run | experiment | a run carries out an experiment |
 | `produced` | run | artifact, result | a run produced a result or artifact |
-| `uses` | run | artifact | a run used an artifact (data.role: data / code / model / config) |
+| `uses` | run, experiment | artifact | a run used an artifact (data.role: data / code / model / config); an experiment is designed on one |
 | `derived_from` | artifact, claim, result | artifact, result, run, source | computed or taken from |
 | `supports` | claim, result, source | claim, hypothesis | evidence for (why required) |
 | `challenges` | claim, result, source | claim, hypothesis | evidence against (why required) |
@@ -182,6 +182,7 @@ smallest detectable difference uses 80% power at two-sided α = 0.05.
 | 8 | `SIGNIFICANCE_WITHOUT_TEST` / `SIGNIFICANCE_NOT_SHOWN` | "significantly" / "statistically" with no bound p-value and fewer than two counts, or when the bound p-value, or the test the record runs on the first two counts, is not below 0.05 |
 | 9 | `CAUSAL_WITHOUT_INTERVENTION` | a causal word (causes, leads to, results in, drives, due to, because of, responsible for, …) when no supporting result was produced by a run that `executes` an experiment |
 | 10 | `EXCLUSION_WITHOUT_POWER` | `kind: exclusion`, or wording that says an effect is absent (no effect, no difference, makes no difference, does not affect, rules out, ineffective, …) in a finding, without a supporting result with `power: demonstrated` or one produced by a run of an experiment with a `power_check`. With two counts, the message gives the smallest detectable difference. |
+| 11 | `UNCORRECTED_EFFECT` | a finding asserts an effect (changes, lowers, differs, affects, significant, …) on an outcome, while a live result in the investigation holds that outcome's corrected p-value (a field named with holm / bonferroni / fdr / adjusted / corrected …) at or above 0.05, or a count of 0 outcomes surviving correction (`n_holm_sig`), and the effect word is neither qualified within 20 words as uncorrected (uncorrected, unadjusted, nominally, without correction, …) nor names the correction with a corrected value bound as a measurement. A family-wide value (`min_adjusted_p`) applies when the claim binds a nominal p < 0.05. Thresholds (`bonferroni_alpha_threshold`) are not evidence. Honest forms: bind the corrected p and say "not significant after correction", or file `kind: lead`. |
 
 **Exposure.** A claim may set `exposure` (how many uses, users or units it will be applied to) and `exposure_unit`.
 Absolute refusals then state how many failures the bound leaves unruled out at that scale. An accepted claim's
@@ -198,13 +199,26 @@ A refused claim never enters the record, so its trace lives in a separate append
 its own SHA-256 chain over `canon({at, kind, author, inv, node, op, statement, codes, detail, ref, prev})`. The
 record's own chain and `verify()` are unaffected.
 
-- `kind: refused`: the author, the investigation, the statement (≤ 1,500 characters), the sorted codes, and the
-  problems (code, message, fix) it was refused with. `op` is `create` or `revise`; `node` is set for a revision.
-- `kind: fixed`: a later claim or revision by the same author in the same investigation, accepted within 24 hours,
-  that says the same thing. "The same" means the same node for a revision; otherwise a Jaccard overlap ≥ 0.3 of the
-  statements' content words. `ref` is the refusal it fixes.
-
-A report aggregates per author (refused, fixed, open, codes) and per rule.
+- `kind: refused`: the author, the investigation, the statement (≤ 1,500 characters; a result's summary), the
+  sorted codes, and the problems (code, message, fix) it was refused with; `detail` holds the whole body, the
+  support it had and the node type (`claim`, `result`, or a typed node). `op` is `create` or `revise`; `node` is
+  set for a revision.
+- A refusal on *shape* — a field the type doesn't have (`SHAPE_UNKNOWN_FIELD`), a value outside an enum
+  (`SHAPE_NOT_AN_OPTION`), a missing, too long or too short field, a wrong type, or a link the relation grammar
+  refuses (`LINK_NOT_ALLOWED`, `LINK_UNKNOWN_RELATION`, `LINK_NO_NODE`) — is logged the same way with
+  `detail.type` `shape` or `link`. Its message carries the fix: where the field goes (`code` on a result belongs to
+  the run; an experiment's `expected` goes on its `tests` link) or what each option means. The report counts these
+  apart from overclaims and the replay skips them.
+- `kind: fixed`: a later claim, result or revision by the same author in the same investigation, accepted within
+  24 hours, that says the same thing. "The same" means the same node for a revision; otherwise a Jaccard overlap
+  ≥ 0.3 of the statements' content words, or, for a result, at least half of the refused result's value keys carried
+  again. `ref` is the refusal it fixes.
+
+A report aggregates per author (refused, fixed, open, codes) and per rule. A replay runs every logged refusal through
+the checker as it is now — claims through the claim and profile checks, results through the value and profile result
+checks as their author — and says for each whether it would be refused the same way, differently, or accepted;
+`RESULT_RESTATES` and typed-node refusals depend on the record's state at the time and are counted as skipped. A
+change to a rule is judged on that replay over the real corpus before it ships.
 
 ## 9. Checking a write-up against the record
 

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

{hypgraph-0.7.1 → hypgraph-0.7.3}/src/hypgraph/checks.py

@@ -27,6 +27,15 @@ and each refusal does the arithmetic the writer skipped, then offers the honest
   CAUSAL_WITHOUT_INTERVENTION   "causes" / "leads to" when no experiment intervened
   EXCLUSION_WITHOUT_POWER       "no effect" / "rules out" without a search shown to find a planted effect
   CONVENTION_HEDGED             a convention that hedges
+  VALUE_NOT_A_NUMBER            (results) a value's k or n is not a number: {"k": "40/50", "n": "rank 1 of 20"}
+  UNCORRECTED_EFFECT            a finding says an outcome changed / differs / is significant on an uncorrected
+                                test, while a live result in the investigation holds that outcome's corrected
+                                (Holm / Bonferroni / FDR …) p-value at or above 0.05, or a count of 0 outcomes
+                                surviving correction — and neither is the effect word qualified, within 20
+                                words, as uncorrected ("differs at uncorrected p < 0.05"), nor is the correction
+                                named with a corrected value bound. Two of twelve runs of a 20-outcome trial settled "the supplement
+                                changes steps_k" as a finding, hedged only in the scope field, while the same
+                                record's Holm-corrected p was 0.25.
 
 A word counts only when its sentence asserts it (language.asserted): "not significantly better", "no evidence
 that it ever fails" and "we cannot conclude that…" are honest and pass; the overclaim is the unnegated form.
@@ -43,13 +52,14 @@ from dataclasses import dataclass, field
 
 from . import language as L
 from . import stats
-from .derive import Snap, producing_run, result_value
+from .derive import Snap, lifecycle, producing_run, result_value
 
 _NUM = re.compile(r"(?<![\w.])(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?(\s*%)?(?![\w])")
 _WORDS = {w: i for i, w in enumerate("two three four five six seven eight nine ten eleven twelve thirteen fourteen "
                                      "fifteen sixteen seventeen eighteen nineteen twenty".split(), start=2)}
-_WORDNUM = re.compile(r"\b(" + "|".join(_WORDS) + r")\b", re.I)   # 'one' is left out: too common as a pronoun
-_LABEL = re.compile(r"""(['"`‘“])[0-9][0-9 ]{0,30}(['"`’”])""")
+_WORDNUM = re.compile(r"(?<!-)\b(" + "|".join(_WORDS) + r")\b(?!-)", re.I)   # 'one' is left out: too common as a
+_LABEL = re.compile(r"""(['"`‘“])[0-9][0-9 ]{0,30}(['"`’”])""")                 # pronoun; "two-sided" is a name
+_DATE = re.compile(r"\b\d{4}-\d{2}-\d{2}(?:T[\d:.]+)?\b")                      # a date is not a measurement
 # identifiers that look like numbers but aren't measurements: a version (1.10.0, v2.0.0-rc.1), inline code, a number a
 # label word names ("case 8", "cases 9–12", "test 4", "line 12", "#3"), or one that labels the literal after it ("9 ('')")
 _NOT_A_FIGURE = re.compile(
@@ -204,7 +214,10 @@ def _exposure_note(bound_rate: float, body: dict) -> str:
 
 _ENUM = re.compile(r"\b(all|every|each|none|neither|both)\b", re.I)
 _SMALL = r"(?:\d{1,3}(?:,\d{3})*|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve)"
-_ENUM_COUNT = re.compile(r"^\s*(?:of\s+(?:the\s+)?|one\s+of\s+(?:the\s+)?)?" + _SMALL + r"\b", re.I)
+_ENUM_COUNT = re.compile(r"^\s*(?:(?:of|other|remaining|but one of|one of)\s+)?(?:the\s+|these\s+|those\s+|its\s+)?"
+                         r"(?:other\s+|remaining\s+)?" + _SMALL + r"\b", re.I)
+# the set was counted just before the word, in the same clause: "cases 1-7 all pass", "the 20 outcomes all have"
+_ENUM_BEFORE = re.compile(r"(?:\d+\s*[-–]\s*\d+|\b" + _SMALL + r"\b)(?:\s+[\w-]+){0,2}\s*$", re.I)
 
 
 def _enumerated(stmt: str, word: str) -> bool:
@@ -220,12 +233,21 @@ def _enumerated(stmt: str, word: str) -> bool:
     rest = re.split(r"[.!?](?:\s|$)", stmt[m.end():], maxsplit=1)[0]
     if _ENUM_COUNT.match(rest):
         return True
+    head = stmt[:m.start()]
+    c0 = max((x.end() for x in L._CLAUSE.finditer(head)), default=0)
+    if _ENUM_BEFORE.search(head[c0:]):
+        return True
     brk = re.search(r"[:(\[—]", rest)
     return bool(brk) and len(numbers(rest[brk.end():])) >= 2
 
 
+_PROVEN = re.compile(r"^prov(?:es?|en|ed)$|^proof$", re.I)
+
+
 def _absolutes(stmt: str, scope: str, body: dict, bound: list) -> list[Problem]:
     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
     if not words:
         return []
     w = words[0]
@@ -285,7 +307,13 @@ def _measured_claim(s: Snap, support: list[str]) -> bool:
     return False
 
 
-_PNAME = re.compile(r"^(p|pval|pvalue|p[_-]?val(?:ue)?|p[_-][a-z0-9_]+)$", re.I)
+def _is_p_key(key: str) -> bool:
+    """A result field holding a p-value, by its name: a token ``p`` anywhere (p, p_value, p_welch, welch_two_sided_p,
+    raw_p_steps_k, steps_k_p), or pval / pvalue / padj — the record's agents name p-values both ways round."""
+    toks = [t for t in re.split(r"[^a-z0-9]+", key.lower()) if t]
+    if "top" in toks or _NOT_EVIDENCE.search(key):             # top_p is a sampling parameter; a threshold is a convention
+        return False
+    return "p" in toks or any(t in ("pval", "pvalue", "pvalues", "padj") for t in toks)
 
 
 def _p_values(s: Snap, bound: list, support: list[str]) -> list[float]:
@@ -295,7 +323,7 @@ def _p_values(s: Snap, bound: list, support: list[str]) -> list[float]:
     for m, rv in bound:
         key = str(m.get("key") or m.get("name") or "")
         v = rv.get("value")
-        if _PNAME.match(key) and isinstance(v, (int, float)) and not isinstance(v, bool) and 0 <= v <= 1:
+        if _is_p_key(key) and isinstance(v, (int, float)) and not isinstance(v, bool) and 0 <= v <= 1:
             ps.append(float(v))
     for rid in support:
         n = s.nodes.get(rid)
@@ -303,7 +331,7 @@ def _p_values(s: Snap, bound: list, support: list[str]) -> list[float]:
             continue
         for key, rv in (n["body"].get("values") or {}).items():
             v = rv.get("value") if isinstance(rv, dict) else rv
-            if _PNAME.match(str(key)) and isinstance(v, (int, float)) and not isinstance(v, bool) and 0 <= v <= 1:
+            if _is_p_key(str(key)) and isinstance(v, (int, float)) and not isinstance(v, bool) and 0 <= v <= 1:
                 ps.append(float(v))
     return ps
 
@@ -323,9 +351,17 @@ def _comparisons(s: Snap, stmt: str, bound: list, support: list[str]) -> list[Pr
     support_p = _p_values(s, [], support)                  # a named p on a supporting result: the last resort
     arms = [_arm(rv) for _m, rv in bound if _arm(rv)]
     no_sig = L.denied(L.SIGNIFICANCE, stmt)
-    if no_sig and not sig:                      # "not significant": the record checks that too
-        p = min(bound_p) if bound_p else (stats.two_proportions(*arms[0], *arms[1])["p"] if len(arms) >= 2
-                                          else (min(support_p) if support_p else None))
+    corrected_p = _p_values(s, [(m, rv) for m, rv in bound if _corrected_key(str(m.get("key") or ""))], [])
+    # "not significant": the record checks that too — against the corrected p-values when the sentence names a
+    # correction (a raw p below 0.05 is what "not significant after correction" is about), and not at all when the
+    # sentence also asserts an effect ("exactly one differs …; the other 19 are not significant" denies the others)
+    if no_sig and not sig and not L.asserted(L.EFFECT, stmt):
+        if _CORRECTION_NAMED.search(stmt):
+            p = min(corrected_p) if corrected_p else None
+        else:
+            pool = bound_p
+            p = min(pool) if pool else (stats.two_proportions(*arms[0], *arms[1])["p"] if len(arms) >= 2
+                                        else (min(support_p) if support_p else None))
         if p is not None and p < 0.05:
             out.append(Problem("SIGNIFICANCE_CONTRADICTED",
                                f"the statement denies significance ('{no_sig[0]}'), but the bound evidence is "
@@ -375,8 +411,13 @@ def _causal(s: Snap, stmt: str, support: list[str]) -> list[Problem]:
                     "experiment.", fix="say 'is associated with'", words=words)]
 
 
+# "no difference remains significant after correction": a sentence about a test's verdict, not an absence claim
+_SURVIVAL = re.compile(r"\b(surviv\w*|correct(?:ed|ion|ing)|remains? significant|reach(?:es)? significance)\b", re.I)
+
+
 def _exclusion(s: Snap, stmt: str, kind: str, support: list[str], bound: list) -> list[Problem]:
-    words = L.asserted(L.EXCLUSION, stmt)
+    words = [w for w in L.asserted(L.EXCLUSION, stmt)
+             if not (L.denied(L.SIGNIFICANCE, _near(stmt, w)) or _SURVIVAL.search(_near(stmt, w)))]
     if kind != "exclusion" and not (words and kind not in ("inconclusive", "lead", "convention")):
         return []
     for sid in support:
@@ -405,6 +446,146 @@ _PLACEHOLDER = re.compile(r"^\W*(?:(?:placeholder|tbd|todo|tba|n/?a|none|wip|xxx
                           r"to be (?:determined|confirmed|added)|lorem ipsum)\W*)+$", re.I)
 
 
+# ── multiplicity ─────────────────────────────────────────────────────────────
+# A result field holding a corrected p-value or a count of outcomes surviving correction, by its key:
+# p_holm_steps_k, steps_k_bonferroni_adj_p, min_adjusted_p, n_holm_sig, n_bonferroni_significant. A threshold
+# (bonferroni_alpha_threshold = 0.0025) is a convention, not evidence.
+_CORRECTED = re.compile(r"(?<![a-z])(holm|bonferroni|sidak|fdr|bh|benjamini|hochberg|fwer|adj|adjusted|corrected|corr)"
+                        r"(?![a-z])", re.I)
+_P_KEY = re.compile(r"(?<![a-z])(p|pval|pvalue|p_?value|padj|q|qval|qvalue)(?![a-z])", re.I)
+_COUNT_KEY = re.compile(r"(?<![a-z])(sig|signif|significant|surviv\w*|rejected|rejections|discoveries)(?![a-z])", re.I)
+_NOT_EVIDENCE = re.compile(r"(?<![a-z])(alpha|thresh(?:old)?|thr|cutoff|level|critical|crit)(?![a-z])", re.I)
+_FAMILY = {"min", "max", "smallest", "largest", "family", "overall", "global", "any", "all", "n", "num", "count",
+           "outcomes", "tests", "value", "after", "two", "sided"}
+# the sentence says the test it rests on is uncorrected: "differs at uncorrected p < 0.05", "changes steps_k only
+# nominally" — the reader is told, in the sentence, and the rule leaves it to the reviewer
+_UNCORRECTED_SAID = re.compile(r"\b(uncorrected|unadjusted|nominal(?:ly)?|raw p|without (?:multiplicity |any )?correction|"
+                               r"before (?:multiplicity |any )?correction|not corrected|no (?:multiplicity )?correction|"
+                               r"per-outcome|single-outcome)\b", re.I)
+# the statement names the correction: "Holm p = 0.25", "after Bonferroni correction", "corrected for multiplicity"
+_CORRECTION_NAMED = re.compile(r"\b(correct(?:ed|ion|ing)|adjust(?:ed|ment)|holm|bonferroni|[sš]id[aá]k|fdr|benjamini|"
+                               r"family-?wise|multiplicity|multiple (?:testing|comparisons|outcomes))\b", re.I)
+
+
+def _corrected_key(key: str) -> bool:
+    return bool(_CORRECTED.search(key)) and not _NOT_EVIDENCE.search(key)
+
+
+def _fails_correction(key: str, rv: dict) -> str:
+    """How a corrected value says the effect doesn't survive — 'p_holm_x = 0.25', 'n_holm_sig = 0 of 20' — or ''."""
+    if _COUNT_KEY.search(key):
+        a = _arm(rv)
+        count = a[0] if a else rv.get("value")
+        if isinstance(count, (int, float)) and not isinstance(count, bool) and count == 0:
+            return f"{key} = 0" + (f" of {a[1]}" if a else "")
+        return ""
+    if _P_KEY.search(key):
+        v = rv.get("value")
+        if isinstance(v, (int, float)) and not isinstance(v, bool) and 0.05 <= v <= 1:
+            return f"{key} = {v:.3g}"
+    return ""
+
+
+def _corrected_evidence(s: Snap, inv: str) -> list[tuple[str, str, str, list[str]]]:
+    """Every corrected value on the investigation's live results in which an effect does not survive:
+    (result id, key, how it says so, the outcome tokens the key names — empty for a family-wide value)."""
+    out = []
+    for rid, n in s.nodes.items():
+        if n["type"] != "result" or n.get("inv") != inv or lifecycle(s, rid) != "active":
+            continue
+        for key in (n["body"].get("values") or {}):
+            k = str(key)
+            if not _corrected_key(k):
+                continue
+            rv = result_value(s, rid, k)
+            how = _fails_correction(k, rv) if rv else ""
+            if not how:
+                continue
+            toks = [t for t in re.split(r"[^a-z0-9]+", k.lower()) if t]
+            outcome = [t for t in toks if not (_CORRECTED.fullmatch(t) or _P_KEY.fullmatch(t) or _COUNT_KEY.fullmatch(t)
+                                                or t in _FAMILY)]
+            out.append((rid, k, how, outcome))
+    return out
+
+
+_SENT = re.compile(r"[.!?](?=\s|$)")              # a full stop before space or the end: not the one in "p < 0.05"
+
+
+_WINDOW = 20                                     # words either side of the effect word that can qualify it
+
+
+def _near(text: str, word: str) -> str:
+    """The words around the word's first occurrence — up to _WINDOW either side, within its sentence. A qualifier
+    counts only here: "differs at uncorrected p < 0.05" is qualified; "changes steps_k … (sixty words) … while
+    dropping its uncorrected p < 0.05 claim" is not, though both sit in one sentence."""
+    m = re.search(r"\b" + re.escape(word) + r"\b", text, re.I)
+    if not m:
+        return ""
+    starts = [x.end() for x in _SENT.finditer(text, 0, m.start())]
+    ends = [x.start() for x in _SENT.finditer(text, m.end())]
+    s0, s1 = (starts[-1] if starts else 0), (ends[0] if ends else len(text))
+    before = re.findall(r"\S+", text[s0:m.start()])[-_WINDOW:]
+    after = re.findall(r"\S+", text[m.start():s1])[:_WINDOW + 1]
+    return " ".join(before + after)
+
+
+def _uncorrected(s: Snap, stmt: str, bound: list, inv: str) -> list[Problem]:
+    """A finding that asserts an effect the record's own corrected result says does not survive."""
+    words = L.asserted(L.EFFECT, stmt)
+    words += [w for w in L.asserted(L.SIGNIFICANCE, stmt) if w not in words]
+    words = [w for w in words if not _UNCORRECTED_SAID.search(_near(stmt, w))]
+    if not words or not inv:
+        return []
+    nominal = any(p < 0.05 for p in _p_values(s, [(m, rv) for m, rv in bound
+                                                  if not _CORRECTED.search(str(m.get("key") or ""))], []))
+    hits = []
+    for rid, key, how, outcome in _corrected_evidence(s, inv):
+        if outcome:
+            pat = r"(?<![a-z0-9])" + r"[ _\-]?".join(re.escape(t) for t in outcome) + r"(?![a-z0-9])"
+            if re.search(pat, stmt, re.I):          # the statement names the outcome (a scope may name others)
+                hits.append((0, rid, key, how, "_".join(outcome)))
+        elif nominal:                   # a family-wide value applies when the claim rests on a nominal p < 0.05
+            hits.append((1, rid, key, how, ""))
+    if not hits:
+        return []
+    named = bool(_CORRECTION_NAMED.search(stmt))
+    binds = any(_corrected_key(str(m.get("key") or "")) for m, _rv in bound)
+    if named and binds:
+        return []
+    hits.sort(key=lambda h: h[0])
+    _, rid, _key, how, outcome = hits[0]
+    seen = f"{s.nodes[rid]['code'] or rid}.{how}"
+    w = words[0]
+    about = f"an effect on {outcome}" if outcome else "an effect"
+    lack = ("the corrected value is bound, but the statement doesn't say so" if binds else
+            "the statement names the correction but binds none of its values" if named else
+            "the claim binds none of that and its statement doesn't say so")
+    return [Problem("UNCORRECTED_EFFECT",
+                    f"'{w}' asserts {about} from an uncorrected test, but the record holds the corrected result: "
+                    f"{seen} — the effect does not survive correction over the family. {lack.capitalize()}: bind "
+                    "the corrected value as a measurement and say in the statement that it does not survive "
+                    "correction ('uncorrected p = …; Holm p = …, not significant after correction over the N "
+                    "outcomes'); or say beside the effect word that the test is uncorrected; or file this as kind=lead.",
+                    fix="bind the corrected p and say it does not survive correction, say 'uncorrected' in the "
+                        "sentence, or file it as kind=lead",
+                    words=words)]
+
+
+def value_issues(body: dict) -> list[Problem]:
+    """A result's values: a count's k and n must be numbers. A quant registered {"k": "40/50", "n": "rank 1 of 20"}
+    (a grid setting and its rank) as a count; every reader guards against it except the one that crashed a run."""
+    out: list[Problem] = []
+    for key, v in (body.get("values") or {}).items():
+        if not isinstance(v, dict) or not ("k" in v or "n" in v):
+            continue
+        bad = [f"{f}={v[f]!r}" for f in ("k", "n") if f in v and (not isinstance(v[f], (int, float)) or isinstance(v[f], bool))]
+        if bad:
+            out.append(Problem("VALUE_NOT_A_NUMBER", f"values.{key}: k and n must be numbers ({', '.join(bad)}) — a "
+                               "label such as a setting or a rank goes in the summary, or under its own key as "
+                               "{\"value\": \"40/50\"}", fix=f"give values.{key} numeric k and n, or move the label"))
+    return out
+
+
 def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Problem]:
     """What's wrong with a claim, each with a code, a message and a fix (empty = it may enter the record).
     ``support``: ids of the nodes that support it or that it is derived from."""
@@ -431,7 +612,7 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
                                 "supports it (links: {\"rel\": \"supports\", \"from\": <result id>, \"why\": …})"))
     bound, bad = _bound(s, body.get("measurements") or [])
     problems += bad
-    clean = _LABEL.sub(" ", stmt)
+    clean = _DATE.sub(" ", _LABEL.sub(" ", stmt))
     plain, stat = derived_numbers(bound)
     allowed = plain + [v for v, *_ in numbers(scope)] + \
         [float(c) for c in (invb.get("constants") or []) if isinstance(c, (int, float))]
@@ -448,7 +629,8 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
                                 "scope", fix="bind each number to a result field", words=[p[3] for p in loose[:8]]))
     keys = {str(m.get("key") or "") for m in body.get("measurements") or [] if isinstance(m, dict)}
     named = [k for k in sorted(keys) if ("_" in k or any(ch.isdigit() for ch in k)) and len(k) >= 4
-             and re.search(rf"(?<![\w`]){re.escape(k)}(?![\w`])", stmt)]
+             and re.search(rf"(?<![\w`]){re.escape(k)}(?![\w`])", stmt)
+             and not re.search(rf"(?<![\w`]){re.escape(k)}\s*(?:=|:|≈|is|was|of|at)\s*[-+−]?\d", stmt)]   # key = value
     if named:
         problems.append(Problem("KEY_FOR_NUMBER", "the statement names a measurement's key instead of saying its value: "
                                 + ", ".join(named[:6]) + " — write the number in the sentence; it's bound to that key, "
@@ -458,6 +640,8 @@ def claim_issues(s: Snap, body: dict, support: list[str], inv: str) -> list[Prob
         problems += _comparisons(s, clean, bound, support)
         problems += _causal(s, clean, support)
     problems += _exclusion(s, clean, kind, support, bound)
+    if kind == "finding":
+        problems += _uncorrected(s, clean, bound, inv)
     return problems
 
 

{hypgraph-0.7.1 → hypgraph-0.7.3}/src/hypgraph/coord.py

@@ -451,7 +451,10 @@ def accept_work(g: "Graph", *, author: str, order: str, reason: str = "", text:
           if s.nodes[i]["type"] in ("claim", "result", "hypothesis")]
     ev = list(dict.fromkeys(ev))
     met = "; ".join(f"{c['p']}: {', '.join(c['evidence_codes']) or 'met'}" for c in chk["predicates"])
-    fields = {"choice": f"Accept {chk['code']}: {s.nodes[order]['body']['objective'][:200]}",
+    # kind=accepted: the record's bookkeeping, not a position — under trading a kind-less decision whose text quoted
+    # an objective about a "paper position" and that rested on the claims was refused for want of a stop, and the run
+    # crashed as it settled (studies T2)
+    fields = {"choice": f"Accept {chk['code']}: {s.nodes[order]['body']['objective'][:200]}", "kind": "accepted",
               "reasons": (reason.strip() + " — " if reason.strip() else "") + f"every predicate met ({met})"}
     links = [{"rel": "settles", "to": order}] + [{"rel": "based_on", "to": i} for i in ev]
     d = g.create(author=author, type="decision", inv=s.nodes[order]["inv"], fields=fields, links=links)