hypgraph 0.7.0__tar.gz → 0.7.2__tar.gz

{hypgraph-0.7.0 → hypgraph-0.7.2}/CHANGELOG.md

@@ -1,5 +1,64 @@
 # Changelog
 
+## 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
+  `solved`, trading's `backtested` and the scientific workflow's evidenced stage (`result_exists` under a
+  scientific profile) count only results something can re-run: the run that produced them carries its code, or
+  it is the instrument's (`kind=lab`). Through the hypswarm CLI, with no tool that executes code, the seats wrote
+  "exact DP over capacity" and "brute force over 2^21" as prose; the verifier passed a wrong optimum (757 for
+  656) and the question settled. The gate now says which results report a computation with no code behind it.
+  `workflow.rerunnable(snap, result)`.
+- **A question settles only when every live answer to it is checked.** A checked answer beside a live unchecked one
+  used to settle the question, and the two may disagree: in a real-model trading run a reviewer re-ran the numbers
+  behind "no look-ahead" and checked it while "it is look-ahead" stood unchecked on the same question. The board row
+  now says `answered` with the unchecked answers named (`unchecked`), the reviewed gate names them, and completion
+  waits. An answer nobody may review (its author is the only reviewer) doesn't block; the row lists it under
+  `unreviewable`. `derive.unchecked_answers` / `unreviewable_answers`.
+- **Measuring returns isn't trading them.** Trading's BACKTEST_WITHOUT_COSTS no longer fires on a result that counts
+  its returns (`n_returns`, `insample_n_returns`, a value in units of returns, days, bars or trades) or reports a
+  statistic of them (an autocorrelation, its t, p, standard error or CI). A return, P&L or Sharpe still needs its
+  costs. A real-model run lost eight writes measuring a lag-1 autocorrelation.
+- **A confidence interval that excludes zero isn't an exclusion.** "Excludes zero", "excludes 1" (a ratio's
+  null) and "rules out chance" say an effect is there, so they no longer need a power check
+  (EXCLUSION_WITHOUT_POWER). "Rules out an effect" and "no effect" still do.
+
 ## 0.7.0 — 2026-10-27: measure questions, and claim checks that know a version from a figure
 
 - **Measure questions.** A question may say `asks: "measure"`, and its workflow's `measure_skips` gates then don't

{hypgraph-0.7.0 → hypgraph-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.7.0
+Version: 0.7.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/
@@ -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.0 → hypgraph-0.7.2}/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.0 → hypgraph-0.7.2}/docs/spec.md

@@ -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

{hypgraph-0.7.0 → hypgraph-0.7.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.7.0"
+__version__ = "0.7.2"
 
 from .bundle import verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

{hypgraph-0.7.0 → hypgraph-0.7.2}/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.0 → hypgraph-0.7.2}/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)
@@ -729,7 +732,13 @@ def question_board(g: "Graph", inv: str) -> list[dict]:
         checked = [c for c in ans if states[c] == "checked"]
         contested = [c for c in ans if states[c] == "contested"]
         o = open_orders.get(q)
-        if checked:
+        pending = D.unchecked_answers(s, q)
+        if checked and pending:
+            # two live answers, one checked: settled only once every live answer is checked (they may disagree)
+            status, by = "answered", (f"{', '.join(_code(s, c) for c in pending[:3])} unchecked beside "
+                                      f"{_code(s, checked[0])} (checked) — review it, or withdraw the wrong answer"
+                                      + (f"; order {o['code']} on it" if o else ""))
+        elif checked:
             status, by = "settled", f"{_code(s, checked[0])} (checked by " + ", ".join(
                 x.split(":")[0] for x in D.state(s, checked[0])["review"]["positive"][:2]) + ")"
         elif contested:
@@ -741,7 +750,8 @@ def question_board(g: "Graph", inv: str) -> list[dict]:
         else:
             status, by = "open", ""
         rows.append({"id": q, "code": n["code"], "text": _title(s, q), "status": status, "by": by,
-                     "answers": [_code(s, c) for c in ans]})
+                     "answers": [_code(s, c) for c in ans], "unchecked": [_code(s, c) for c in pending],
+                     "unreviewable": [_code(s, c) for c in D.unreviewable_answers(s, q)]})
     return rows
 
 

{hypgraph-0.7.0 → hypgraph-0.7.2}/src/hypgraph/derive.py

@@ -237,6 +237,30 @@ def _moved_since(s: Snap, rid: str) -> list[str]:
     return out
 
 
+def _open_answers(s: Snap, q: str) -> list[str]:
+    return [e["src"] for e in s.inn.get(q, []) if e["rel"] == "answers" and s.nodes[e["src"]]["type"] == "claim"
+            and lifecycle(s, e["src"]) == "active" and not fallen(s, e["src"]) and not stale(s, e["src"])
+            and (state(s, e["src"]).get("review") or {}).get("state") != "checked"]
+
+
+def reviewable(s: Snap, nid: str) -> bool:
+    """Someone besides its author (and the curators) may review it."""
+    return bool(board(s, nid) - set(s.policy.curators) - {s.nodes[nid]["created_by"]})
+
+
+def unchecked_answers(s: Snap, q: str) -> list[str]:
+    """Live, fresh claims answering question ``q`` that no reviewer has checked and one could. A question settles only
+    when this is empty: a checked answer beside a live unchecked one is two answers the record hasn't reconciled, and
+    they may disagree (studies T1: "no look-ahead" checked while "is look-ahead" stood unchecked on the same
+    question). An answer nobody may review (its author is the only reviewer) can't block it; ``unreviewable_answers``
+    lists those."""
+    return [c for c in _open_answers(s, q) if reviewable(s, c)]
+
+
+def unreviewable_answers(s: Snap, q: str) -> list[str]:
+    return [c for c in _open_answers(s, q) if not reviewable(s, c)]
+
+
 def stale(s: Snap, nid: str) -> list[str]:
     """Why a result (or a claim through its results) no longer speaks for what it measured; [] when fresh. A result
     is stale when the run that produced it used an artifact that is now superseded or withdrawn, or when its

{hypgraph-0.7.0 → hypgraph-0.7.2}/src/hypgraph/graph.py

@@ -29,7 +29,7 @@ from typing import Any, Callable, Optional
 from . import profiles
 from . import derive as D
 from . import refusals, store
-from .checks import claim_issues
+from .checks import claim_issues, value_issues
 from .policy import Policy
 from .schema import REPLICATION, RELS, SAME_TYPE, SYNONYMS, TYPES, VERDICTS
 from .store import canon, now
@@ -624,7 +624,7 @@ class Graph:
                                                 problems=found, support=self._support_ids(s, nid, pending))
                         raise GraphError("claim refused:\n- " + "\n- ".join(p.text() for p in problems), found)
                 if type == "result" and author not in P.curators:
-                    rp = profiles.result_issues(s, inv, body, pending)
+                    rp = value_issues(body) + profiles.result_issues(s, inv, body, pending, author=author)
                     if rp:
                         found = [p.to_dict() for p in rp]
                         refusals.record_refusal(self, author=author, op="create", inv=inv, node="", body=body,

{hypgraph-0.7.0 → hypgraph-0.7.2}/src/hypgraph/language.py

@@ -7,6 +7,7 @@ a word earns its place by a mistake it would have caught.
 - SIGNIFICANCE  "significantly", "statistically" … — says a test was passed.
 - CAUSAL        "causes", "leads to", "because of" … — says an intervention would change the outcome.
 - EXCLUSION     "no effect", "makes no difference", "rules out" … — says an effect is absent.
+- EFFECT        "changes", "lowers", "differs", "affects" … — says an intervention or condition moved an outcome.
 """
 
 from __future__ import annotations
@@ -22,7 +23,8 @@ COMPARATIVE = re.compile(
     r"\b(better|worse|beats?|beat|outperform(?:s|ed|ing)?|underperform(?:s|ed|ing)?|improv(?:es|ed|ement|ing)|"
     r"superior|inferior|exceeds?|exceeded|higher than|lower than|more than|fewer than|less than|faster|slower|"
     r"gains? over|uplift|lift over|advantage over|wins? over|surpass(?:es|ed)?)\b", re.I)
-SIGNIFICANCE = re.compile(r"\b(significant(?:ly)?|statistically|reliably (?:better|worse|higher|lower))\b", re.I)
+SIGNIFICANCE = re.compile(r"\b(significant(?:ly)?|statistically(?!\s+(?:in|non-?|not\b|un))|"
+                          r"reliably (?:better|worse|higher|lower))\b", re.I)
 CAUSAL = re.compile(
     r"\b(caus(?:es|ed|ing|al)|cause|leads? to|led to|resulted in|drives?|driven by|due to|because of|"
     r"responsible for|is the reason)\b", re.I)
@@ -30,7 +32,13 @@ EXCLUSION = re.compile(
     r"\b(no (?:effect|difference|impact|influence|benefit|improvement|association|relationship)|"
     r"makes? no difference|has no bearing|(?:does|do|did)(?: not|n't) (?:affect|matter|help|work|change|improve)|"
     r"doesn't (?:affect|matter|help|work|change|improve)|not (?:associated|related|correlated)|ineffective|"
-    r"useless|rules? out|ruled out|excludes?|unrelated to)\b", re.I)
+    r"useless|(?:rules? out|ruled out|excludes?)(?!\s+(?:zero|0(?:\.0+)?|the null|null|chance|a zero|one|"
+    r"1(?:\.0+)?)\b)|unrelated to)\b", re.I)
+# "the 95 % CI excludes zero", "rules out chance": leaving out the null value asserts an effect, not its absence
+EFFECT = re.compile(
+    r"\b(chang(?:e|es|ed|ing)|alters?|altered|lowers?|lowered|rais(?:e|es|ed)|increas(?:e|es|ed|ing)|"
+    r"decreas(?:e|es|ed|ing)|reduc(?:e|es|ed|ing)|improv(?:e|es|ed|ing)|worsens?|worsened|affects?|affected|differs?|"
+    r"differed|different|shifts?|shifted|boosts?|boosted|an effect on|effect of|associated with)\b", re.I)
 HEDGE = re.compile(r"\b(could|might|may|likely|probably|perhaps|possibly|suggests?|consistent with|"
                    r"aligns? with|plausibl\w*)\b", re.I)
 
@@ -47,7 +55,9 @@ _SENTENCE_END = re.compile(r"[.!?]")
 _EPISTEMIC = re.compile(
     r"\b(cannot|can't|could not|couldn't|unable to|impossible to|not possible to)\s+(?:yet\s+|fully\s+|reliably\s+|"
     r"safely\s+)?(conclude|say|tell|rule|determine|confirm|establish|show|claim|distinguish|exclude|prove|know|"
-    r"assess|infer|verify|support|demonstrate|decide|be sure|be certain)\b", re.I)
+    r"assess|infer|verify|support|demonstrate|decide|be sure|be certain|"
+    r"be (?:asserted|concluded|confirmed|established|excluded|ruled out|reproduced|used|taken|relied on|the basis))\b",
+    re.I)
 
 
 def negated(text: str, start: int) -> bool:
@@ -59,9 +69,15 @@ def negated(text: str, start: int) -> bool:
 
 
 # "below zero", "crosses zero", "from zero to one": zero as a number on a scale, not "zero failures"
-_ZERO_ON_A_SCALE = re.compile(r"\b(below|above|near|to|from|of|than|at|cross(?:es|ed)?|includ(?:es|ed)?|"
-                              r"exclud(?:es|ed)?|around|about|approximately|spans?|toward|towards|between)\s+zero\b",
-                              re.I)
+_ZERO_ON_A_SCALE = re.compile(r"\b(below|above|near|to|from|of|than|at|cross(?:es|ed)?|includ(?:es|ed|ing)?|"
+                              r"exclud(?:es|ed|ing)?|around|about|approximately|spans?|toward|towards|between|"
+                              r"distinguishable from|different from|differs? from|differ from|equal to|equals?|net|"
+                              r"versus|vs\.?|against|the|a|null of)\s+zero\b", re.I)
+# "almost all", "nearly every", "virtually none": the qualifier says it is not absolute
+_ALMOST = re.compile(r"\b(almost|nearly|virtually|practically|roughly|about|mostly)\s+$", re.I)
+# "the interval lies entirely below zero": where an interval lies, not a rate of 0 or 1
+_INTERVAL_SIDE = re.compile(r"\b(entirely|wholly|completely)\s+(below|above|on|within|inside|outside|negative|"
+                            r"positive|to the|in the|on the|the)\b", re.I)
 
 
 # a sentence that asks: it ends with a question mark (markdown emphasis or a closing quote may follow it)
@@ -87,6 +103,10 @@ def asserted(pattern: re.Pattern, text: str) -> list[str]:
             continue
         if m.group(0).lower() == "zero" and any(z.end() == m.end() for z in _ZERO_ON_A_SCALE.finditer(text)):
             continue
+        if _ALMOST.search(text[:m.start()]):
+            continue
+        if m.group(0).lower() in ("entirely", "wholly", "completely") and _INTERVAL_SIDE.match(text, m.start()):
+            continue
         out.append(m.group(0).lower())
     return list(dict.fromkeys(out))