hypgraph 0.7.0__tar.gz → 0.7.1__tar.gz

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hypgraph
-Version: 0.7.0
+Version: 0.7.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.7.0 → hypgraph-0.7.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.7.0"
+__version__ = "0.7.1"
 
 from .bundle import verify_bundle  # noqa: E402
 from .graph import Author, Graph, GraphError, file_sha256  # noqa: E402

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

@@ -729,7 +729,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 +747,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.1}/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.1}/src/hypgraph/language.py

@@ -30,7 +30,9 @@ 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
 HEDGE = re.compile(r"\b(could|might|may|likely|probably|perhaps|possibly|suggests?|consistent with|"
                    r"aligns? with|plausibl\w*)\b", re.I)
 

{hypgraph-0.7.0 → hypgraph-0.7.1}/src/hypgraph/profiles.py

@@ -583,7 +583,17 @@ def claim_issues(s: D.Snap, inv: str, body: dict, support: list, pending: list)
 
 # a statistic *about* returns (a signal's correlation with tomorrow's return, a hit rate, the volatility) isn't a return
 # a strategy earned and charges no costs: a look-ahead diagnostic was refused three times as a backtest (studies T1)
-_STAT_OF_RETURNS = re.compile(r"corr|agree|match|hit_rate|_ic\b|beta|volatil|std|skew|kurt", re.I)
+_STAT_OF_RETURNS = re.compile(r"corr|agree|match|hit_rate|_ic\b|beta|volatil|std|(?:^|_)sd(?:_|$)|skew|kurt|acf|"
+                              r"autocov|lag\d|"
+                              r"t_?stat|p_?val|_se\b|ci_|_ci\b", re.I)
+# a count of returns is not a return earned: n_returns, insample_n_returns, N_returns_in_sample (studies T3)
+_COUNT_KEY = re.compile(r"(?:^|_)(?:n|num|count|nobs|obs)(?:_|$)|_count\b", re.I)
+_COUNT_UNITS = {"returns", "days", "bars", "obs", "observations", "count", "draws", "trades", "rows", "n"}
+
+
+def _a_count(k: str, v: object) -> bool:
+    unit = str(v.get("unit") or "").strip().lower() if isinstance(v, dict) else ""
+    return bool(_COUNT_KEY.search(k)) or unit in _COUNT_UNITS
 
 
 def result_issues(s: D.Snap, inv: str, body: dict, pending: list | None = None) -> list[Problem]:
@@ -595,7 +605,9 @@ def result_issues(s: D.Snap, inv: str, body: dict, pending: list | None = None)
     if "objective_needs_feasibility" in p.validators and "objective" in v and "feasible" not in v:
         out.append(Problem("OBJECTIVE_WITHOUT_FEASIBILITY", "a result reports an objective value without saying whether "
                            "the solution is feasible", fix="add values.feasible (true/false) and bound or gap"))
-    earned = [k for k in v if re.search(r"return|sharpe|pnl|cagr|profit", k) and not _STAT_OF_RETURNS.search(k)]
+    raw = {str(k).lower(): x for k, x in (body.get("values") or {}).items()}
+    earned = [k for k in v if re.search(r"return|sharpe|pnl|cagr|profit", k) and not _STAT_OF_RETURNS.search(k)
+              and not _a_count(k, raw.get(k))]
     if "backtest_needs_costs" in p.validators and earned and not _has(v, r"fee|cost|slippage|commission"):
         out.append(Problem("BACKTEST_WITHOUT_COSTS", "a backtest result reports returns without the costs it charged",
                            fix="add values for fees and slippage (zero is a value; absence isn't)"))
@@ -630,6 +642,8 @@ def _questions(s: D.Snap, inv: str) -> list[str]:
 
 
 def _settling_claim(s: D.Snap, q: str) -> str:
+    if D.unchecked_answers(s, q):              # a checked answer beside an unchecked one doesn't settle it
+        return ""
     for e in s.inn.get(q, []):
         c = e["src"]
         if e["rel"] == "answers" and s.nodes[c]["type"] == "claim" and _live(s, c) and \

{hypgraph-0.7.0 → hypgraph-0.7.1}/src/hypgraph/workflow.py

@@ -213,8 +213,46 @@ def _stale_why(sc: Scope) -> str:
             "now)") if old else ""
 
 
+def rerunnable(s: D.Snap, r: str) -> bool:
+    """Whether something can re-run the computation behind a result: the run that produced it carries its code, or it
+    is the instrument's own (kind=lab). A run with neither is a report of a computation. In a real run with no tool
+    that executes code, the seats wrote "exact DP over capacity" and "brute force over 2^21" with no code behind them,
+    a wrong optimum (757 for 656) passed its verifier, and the question settled (studies O1 through the CLI)."""
+    for e in s.inn.get(r, []):
+        run = s.nodes.get(e["src"]) or {}
+        if e["rel"] == "produced" and run.get("type") == "run" and _has_code(s, e["src"]):
+            return True
+    return False
+
+
+def _has_code(s: D.Snap, run: str) -> bool:
+    """The instrument's run, or one that carries what it executed: its source (``config.source``, as hypswarm's
+    register_run writes it), its ``code`` list, or an artifact it ``uses`` in the role ``code``."""
+    b = s.nodes[run].get("body") or {}
+    if b.get("kind") == "lab" or str((b.get("config") or {}).get("source") or "").strip() or b.get("code"):
+        return True
+    return any(e["rel"] == "uses" and (e.get("data") or {}).get("role") == "code" for e in s.out.get(run, []))
+
+
+def _computed(sc: Scope, rs: list[str]) -> tuple[list[str], str]:
+    """The results among ``rs`` something can re-run, and why the others don't count."""
+    ok = [r for r in rs if rerunnable(sc.s, r)]
+    bare = [r for r in rs if r not in ok]
+    why = (f" ({', '.join(sc.code(r) for r in bare[-3:])} {'reports a computation' if len(bare) == 1 else 'report computations'}"
+           " with no code behind it: register the run with the code that computed it, so it can be re-run)") if bare else ""
+    return ok, why
+
+
+def _profile(sc: Scope) -> str:
+    return str((sc.s.nodes.get(sc.inv, {}).get("body") or {}).get("profile") or "")
+
+
 def g_result_exists(sc: Scope, now: str) -> dict:
     rs = _current_results(sc)
+    if _profile(sc).startswith("scientific"):
+        # evidenced is the scientific workflow's computed stage ('worker, instrument'): a result there is a computation
+        rs, why = _computed(sc, rs)
+        return _g(bool(rs), rs, f"no live result on {sc.code(sc.root)} that can be re-run{why}{_stale_why(sc)}")
     return _g(bool(rs), rs, f"no live result on {sc.code(sc.root)}{_stale_why(sc)}")
 
 
@@ -239,6 +277,13 @@ def g_reviewed(sc: Scope, now: str) -> dict:
     s = sc.s
     checked = [c for c in sc.claims if _live(s, c) and _checked_since(sc, c)]
     fresh = [c for c in checked if not D.stale(s, c)]
+    pending = D.unchecked_answers(s, sc.root) if s.nodes[sc.root]["type"] == "question" else []
+    if fresh and pending:
+        others = ", ".join(sc.code(c) for c in pending[:3])
+        return _g(False, [], f"{sc.code(fresh[0])} is checked, but {others} also answer{'s' if len(pending) == 1 else ''} "
+                             f"{sc.code(sc.root)} and nobody has checked {'it' if len(pending) == 1 else 'them'} — review "
+                             f"{others}, or withdraw whichever answer is wrong: a question settles when every live answer "
+                             "to it is checked")
     if fresh:
         return _g(True, fresh, "")
     if checked:
@@ -347,7 +392,8 @@ def _trials(v: dict) -> bool:
 def g_backtested(sc: Scope, now: str) -> dict:
     s = sc.s
     nearest, missing = "", []
-    for r in _current_results(sc):
+    results, bare = _computed(sc, _current_results(sc))
+    for r in results:
         v = _vals(s.nodes[r]["body"])
         miss = []
         if not _has(v, r"oos|out_of_sample|holdout|test_"):
@@ -361,8 +407,8 @@ def g_backtested(sc: Scope, now: str) -> dict:
         if not nearest or len(miss) < len(missing):
             nearest, missing = r, miss
     if nearest:
-        return _g(False, [], f"{sc.code(nearest)} lacks {', '.join(missing)}")
-    return _g(False, [], f"no backtest result on {sc.code(sc.root)}{_stale_why(sc)}")
+        return _g(False, [], f"{sc.code(nearest)} lacks {', '.join(missing)}{bare}")
+    return _g(False, [], f"no backtest result on {sc.code(sc.root)}{bare}{_stale_why(sc)}")
 
 
 def _position_missing(body: dict) -> list[str]:
@@ -421,14 +467,15 @@ def g_still_valid(sc: Scope, now: str) -> dict:
 
 def g_solved(sc: Scope, now: str) -> dict:
     s = sc.s
-    for r in _current_results(sc):
+    results, bare = _computed(sc, _current_results(sc))
+    for r in results:
         v = _vals(s.nodes[r]["body"])
         if "feasible" in v and v["feasible"] in (False, 0, "false", "False", "no"):
             return _g(True, [r], "")
         if "objective" in v and v.get("feasible") in _TRUE and ("bound" in v or "gap" in v):
             return _g(True, [r], "")
     return _g(False, [], f"no result on {sc.code(sc.root)} with objective, feasible=true and a bound or gap (or "
-                         "feasible=false)" + _stale_why(sc))
+                         "feasible=false)" + bare + _stale_why(sc))
 
 
 def g_result_reviewed(sc: Scope, now: str) -> dict:
@@ -528,6 +575,8 @@ def stage_of(s: D.Snap, t: str, now: str = "") -> dict:
     if any(st.gate == "tests_pass_current" for st in stages):
         settled += [(c, "verified failure: an instrument-recorded negative result, checked") for c in checked
                     if any(_lab_negative(s, r) for r in _claim_results(s, c))]
+    if settled and s.nodes[q]["type"] == "question" and D.unchecked_answers(s, q):
+        settled = []                             # another live answer is unchecked: the record hasn't reconciled them
     if stage is not None and settled:
         rv = next((i for i, st in enumerate(stages) if st.gate == "reviewed"), len(stages) - 1)
         return {**base, "workflow": True, "stage": stages[rv].name, "index": rv + 1, "of": len(stages),

{hypgraph-0.7.0 → hypgraph-0.7.1}/tests/test_measure_questions.py

@@ -21,7 +21,7 @@ def _g(profile: str, asks: str | None = "measure"):
 
 
 def _measured(g, inv, q):
-    run = g.create(author="w", type="run", inv=inv, fields={"kind": "agent", "name": "count", "state": "succeeded"},
+    run = g.create(author="w", type="run", inv=inv, fields={"kind": "agent", "name": "count", "state": "succeeded", "config": {"source": "print('count')"}},
                    links=[{"rel": "part_of", "to": q}])["id"]
     rs = g.create(author="w", type="result", inv=inv, fields={"summary": "A is right on 781 of 1000 items.",
                   "values": {"a_correct": {"k": 781, "n": 1000}}, "outcome": "positive"},

hypgraph-0.7.1/tests/test_opposed_answers.py

@@ -0,0 +1,99 @@
+"""A question settles only when every live answer to it is checked. A checked answer beside a live unchecked one is
+two answers the record hasn't reconciled, and they may disagree: in studies T1 a reviewer re-ran the numbers behind
+"no look-ahead" and checked it, while "it is look-ahead" stood unchecked on the same question, and the question
+counted as settled with the wrong answer."""
+from hypgraph import Graph, Policy, profiles
+
+H = "harness"
+
+
+def _g(profile: str = "", asks: str = "measure"):
+    g = Graph(policy=Policy(reviewers={"critic"}, extra_reserved={H}))
+    f = {"title": "Opposed answers.", "objective": "See two live answers keep a question open."}
+    if profile:
+        f["profile"] = profile
+    inv = g.create(author=H, type="investigation", fields=f)["id"]
+    q = g.create(author=H, type="question", inv=inv, code="Q1",
+                 fields={"text": "Could the signal be known when a trade on it is placed?", "asks": asks})["id"]
+    return g, inv, q
+
+
+def _answer(g, inv, q, author, statement, corr):
+    run = g.create(author=author, type="run", inv=inv, fields={"kind": "agent", "name": "corr", "state": "succeeded"},
+                   links=[{"rel": "part_of", "to": q}])["id"]
+    rs = g.create(author=author, type="result", inv=inv, fields={
+        "summary": f"The signal's correlation with the next day's return is {corr}.",
+        "values": {"corr_next": {"value": corr}}, "outcome": "positive"},
+        links=[{"rel": "produced", "from": run}])["id"]
+    return g.create(author=author, type="claim", inv=inv, fields={
+        "statement": statement, "scope": "prices.csv, every day.",
+        "measurements": [{"name": "corr", "key": "corr_next", "result": rs}]},
+        links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])["id"]
+
+
+def _board(g, inv):
+    return {r["code"]: r for r in g.question_board(inv)}
+
+
+def test_a_second_live_answer_keeps_the_question_open_until_it_is_checked():
+    g, inv, q = _g()
+    no = _answer(g, inv, q, "quant", "There is no look-ahead: the correlation with the next day is 0.34.", 0.34)
+    g.review(author="critic", target=no, verdict="checked", method="Re-ran the correlation.", notes="0.34 holds.")
+    assert _board(g, inv)["Q1"]["status"] == "settled"
+    yes = _answer(g, inv, q, "risk", "It is look-ahead: the signal agrees with the next day's move, 0.71 of days.", 0.71)
+    row = _board(g, inv)["Q1"]
+    assert row["status"] == "answered" and row["unchecked"] == [g.get(yes)["code"]]
+    assert "unchecked beside" in row["by"] and g.get(no)["code"] in row["by"]
+    crit = {c["name"]: c for c in profiles.completion(g.snapshot(), inv)["criteria"]}
+    assert not crit["questions_settled"]["met"]
+    # the reviewer reads the second answer and objects: it falls, and the first answer settles the question again
+    g.review(author="critic", target=yes, verdict="objection", method="Read both claims against the file.",
+             notes="Contradicts the checked answer; the file's signal column is built from the next close.")
+    assert _board(g, inv)["Q1"]["status"] == "settled"
+
+
+def test_two_checked_answers_settle():
+    g, inv, q = _g()
+    a = _answer(g, inv, q, "quant", "The correlation with the next day's return is 0.34.", 0.34)
+    b = _answer(g, inv, q, "risk", "The signal matches the next day's move on 0.71 of days.", 0.71)
+    for c in (a, b):
+        g.review(author="critic", target=c, verdict="checked", method="Re-ran it.", notes="The numbers hold as stated.")
+    assert _board(g, inv)["Q1"]["status"] == "settled" and _board(g, inv)["Q1"]["unchecked"] == []
+
+
+def test_the_reviewed_gate_names_the_unchecked_answer():
+    g, inv, q = _g("trading@2")
+    no = _answer(g, inv, q, "quant", "There is no look-ahead: the correlation with the next day is 0.34.", 0.34)
+    g.review(author="critic", target=no, verdict="checked", method="Re-ran the correlation.", notes="0.34 holds.")
+    assert g.stage(q)["complete"]
+    yes = _answer(g, inv, q, "risk", "It is look-ahead: the signal agrees with the next day's move, 0.71 of days.", 0.71)
+    st = g.stage(q)
+    gate = next(gt for gt in st["gates"] if gt["gate"] == "reviewed")
+    assert not st["complete"] and not gate["met"]
+    assert g.get(yes)["code"] in gate["why"] and "every live answer" in gate["why"]
+
+
+def test_a_checked_inconclusive_answer_does_not_end_the_question_beside_an_unchecked_finding():
+    g, inv, q = _g("trading@2", asks="")
+    run = g.create(author="quant", type="run", inv=inv, fields={"kind": "agent", "name": "read", "state": "succeeded"},
+                   links=[{"rel": "part_of", "to": q}])["id"]
+    rs = g.create(author="quant", type="result", inv=inv, fields={
+        "summary": "No column in prices.csv says when the signal was published.", "outcome": "inconclusive"},
+        links=[{"rel": "produced", "from": run}])["id"]
+    inc = g.create(author="quant", type="claim", inv=inv, fields={
+        "statement": "Whether the signal is known in time can't be told from these files.",
+        "scope": "prices.csv as given.", "kind": "inconclusive"},
+        links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])["id"]
+    g.review(author="critic", target=inc, verdict="checked", method="Read the files.", notes="Nothing dates the signal.")
+    assert g.stage(q)["complete"]
+    _answer(g, inv, q, "risk", "It is look-ahead: the signal agrees with the next day's move, 0.71 of days.", 0.71)
+    assert not g.stage(q)["complete"]
+
+
+def test_an_answer_nobody_may_review_does_not_block():
+    g, inv, q = _g()
+    mine = _answer(g, inv, q, "critic", "The correlation with the next day's return is 0.34.", 0.34)   # the only reviewer
+    theirs = _answer(g, inv, q, "quant", "The signal matches the next day's move on 0.71 of days.", 0.71)
+    g.review(author="critic", target=theirs, verdict="checked", method="Re-ran it.", notes="The numbers hold as stated.")
+    row = _board(g, inv)["Q1"]
+    assert row["status"] == "settled" and row["unreviewable"] == [g.get(mine)["code"]] and row["unchecked"] == []

hypgraph-0.7.1/tests/test_rerunnable.py

@@ -0,0 +1,75 @@
+"""A computational gate counts only a result something can re-run: the run that produced it carries its code, or it is
+the instrument's (kind=lab). Through the CLI, with no tool that executes code, the seats of an optimization run
+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. solved (optimization), backtested (trading) and the scientific workflow's evidenced
+stage now want the code."""
+import pytest
+
+from hypgraph import Graph, Policy
+
+H = "harness"
+SHA = "a" * 64
+
+
+def _g(profile: str, reviewers=("verifier",)):
+    g = Graph(policy=Policy(reviewers=set(reviewers), extra_reserved={H}))
+    inv = g.create(author=H, type="investigation", fields={"title": "Load the van.", "profile": profile,
+                   "objective": "Find the best selection under the weight limit."})["id"]
+    q = g.create(author=H, type="question", inv=inv, code="Q1",
+                 fields={"text": "What is the highest total value that fits in the van?"})["id"]
+    return g, inv, q
+
+
+def _gate(g, q, name):
+    return next(x for x in g.stage(q)["gates"] if x["gate"] == name)
+
+
+def _solve(g, inv, q, run_fields, author="solver"):
+    inst = g.search("", "artifact", inv, 5)
+    inst = inst[0]["id"] if inst else g.create(author="lead", type="artifact", inv=inv, fields={
+        "sha256": SHA, "path": "items.csv", "kind": "instance"}, links=[{"rel": "part_of", "to": q}])["id"]
+    run = g.create(author=author, type="run", inv=inv, fields={"name": "dp", "state": "succeeded", **run_fields},
+                   links=[{"rel": "uses", "to": inst}])["id"]
+    rs = g.create(author=author, type="result", inv=inv, fields={"summary": "Exact DP over capacity: the optimum.",
+                  "values": {"objective": {"value": 757}, "feasible": {"value": True}, "bound": {"value": 757}},
+                  "outcome": "positive"}, links=[{"rel": "produced", "from": run}])["id"]
+    g.create(author=author, type="claim", inv=inv, fields={"statement": "The highest total value is 757 (bound 757).",
+             "scope": "items.csv at a 212 kg limit."}, links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])
+    return rs
+
+
+def test_a_solve_with_no_code_behind_it_is_not_solved():
+    g, inv, q = _g("optimization@2")
+    rs = _solve(g, inv, q, {"kind": "agent"})
+    gate = _gate(g, q, "solved")
+    assert not gate["met"] and "no code behind it" in gate["why"] and g.get(rs)["code"] in gate["why"]
+
+
+@pytest.mark.parametrize("fields", [{"kind": "agent", "config": {"source": "import csv\nprint('objective', 656)"}},
+                                    {"kind": "agent", "code": ["solve.py"]}, {"kind": "lab"}])
+def test_a_solve_with_its_code_or_by_the_instrument_is_solved(fields):
+    g, inv, q = _g("optimization@2")
+    _solve(g, inv, q, fields, author="lab" if fields["kind"] == "lab" else "solver")
+    assert _gate(g, q, "solved")["met"]
+
+
+def test_a_backtest_with_no_code_is_not_backtested():
+    g, inv, q = _g("trading@2", reviewers=("risk",))
+    run = g.create(author="quant", type="run", inv=inv, fields={"kind": "agent", "name": "bt", "state": "succeeded"})["id"]
+    g.create(author="quant", type="result", inv=inv, fields={"summary": "Backtest out of sample after costs.",
+             "values": {"oos_return": {"value": -0.18}, "fees": {"value": 0.001}, "trials": {"value": 20}},
+             "outcome": "negative"}, links=[{"rel": "produced", "from": run}, {"rel": "part_of", "to": q}])
+    gate = _gate(g, q, "backtested")
+    assert not gate["met"] and "no code behind it" in gate["why"]
+
+
+def test_a_scientific_result_needs_its_code_but_a_sourced_one_does_not():
+    g, inv, q = _g("scientific@2", reviewers=("critic",))
+    run = g.create(author="w", type="run", inv=inv, fields={"kind": "agent", "name": "count", "state": "succeeded"},
+                   links=[{"rel": "part_of", "to": q}])["id"]
+    g.create(author="w", type="result", inv=inv, fields={"summary": "A is right on 781 of 1000 items.",
+             "values": {"a_correct": {"k": 781, "n": 1000}}, "outcome": "positive"}, links=[{"rel": "produced", "from": run}])
+    assert not _gate(g, q, "result_exists")["met"]
+    from hypgraph import workflow as W
+    assert W.GATES["result_exists"] is W.g_result_exists                 # the knowledge workflow doesn't use the gate
+    assert "result_exists" not in {st.gate for st in __import__("hypgraph").profiles.KNOWLEDGE2.workflow.stages}

hypgraph-0.7.1/tests/test_stats_not_backtests.py

@@ -0,0 +1,68 @@
+"""Measuring returns isn't trading them, and a confidence interval that leaves out zero isn't an exclusion. A real-model
+trading run (studies T3, a mean-reversion edge) lost eight writes to BACKTEST_WITHOUT_COSTS on a lag-1
+autocorrelation, because the result also counted its returns (`n_returns`), and three claims to
+EXCLUSION_WITHOUT_POWER for "the bootstrap 95% CI excludes zero" — which says the effect is there."""
+import pytest
+
+from hypgraph import Graph, GraphError, Policy
+from hypgraph import language as L
+
+H = "harness"
+
+
+def _trading():
+    g = Graph(policy=Policy(reviewers={"critic"}, extra_reserved={H}))
+    inv = g.create(author=H, type="investigation", fields={"title": "Reversal.", "profile": "trading@1",
+                   "objective": "Measure the reversal before backtesting it."})["id"]
+    q = g.create(author=H, type="question", inv=inv, code="Q1",
+                 fields={"text": "Is the lag-1 autocorrelation of daily returns distinguishable from zero?"})["id"]
+    return g, inv, q
+
+
+def _result(g, inv, values, summary="Lag-1 autocorrelation of daily returns, in sample."):
+    run = g.create(author="quant", type="run", inv=inv, fields={"kind": "agent", "name": "acf", "state": "succeeded"})
+    return g.create(author="quant", type="result", inv=inv, fields={"summary": summary, "values": values,
+                    "outcome": "positive"}, links=[{"rel": "produced", "from": run["id"]}])["id"]
+
+
+@pytest.mark.parametrize("values", [
+    {"acf1_insample": {"value": -0.09995, "unit": "correlation"}, "insample_n_returns": {"value": 1499, "unit": "returns"}},
+    {"autocorr_lag1": {"value": -0.1008, "unit": "correlation"}, "n_return_obs_in": {"value": 1500, "unit": "returns"}},
+    {"acf1": {"value": -0.100, "unit": "acf"}, "N_returns_in_sample": {"value": 1500, "unit": "returns"},
+     "return_t_stat": {"value": -3.87}, "return_p_value": {"value": 0.0001}},
+    # the T3 re-run's own body: a standard deviation of returns beside the autocorrelation
+    {"in_sample_autocorr_lag1": {"value": -0.1, "unit": "correlation"}, "in_sample_sd_of_daily_return": {"value": 0.0101,
+     "unit": "return"}, "n_pairs": {"value": 1498, "unit": "pairs"}, "t_stat": {"value": -3.87, "unit": "t"}},
+])
+def test_a_statistic_and_a_count_of_returns_need_no_costs(values):
+    g, inv, _q = _trading()
+    _result(g, inv, values)
+
+
+def test_a_return_earned_still_needs_costs():
+    g, inv, _q = _trading()
+    with pytest.raises(GraphError, match="BACKTEST_WITHOUT_COSTS"):
+        _result(g, inv, {"oos_return": {"value": 0.756}, "n_trades": {"value": 795, "unit": "trades"}},
+                summary="Out-of-sample return of the reversal rule.")
+
+
+@pytest.mark.parametrize("text", ["the bootstrap 95% CI excludes zero", "the interval excludes 0.0",
+                                  "the odds ratio's CI excludes 1", "a shuffle test rules out chance"])
+def test_leaving_out_the_null_is_not_an_exclusion(text):
+    assert L.asserted(L.EXCLUSION, text) == []
+
+
+@pytest.mark.parametrize("text", ["the trial rules out an effect", "the data exclude a benefit", "there is no effect"])
+def test_real_exclusions_still_count(text):
+    assert L.asserted(L.EXCLUSION, text)
+
+
+def test_a_claim_that_the_interval_excludes_zero_is_written():
+    g, inv, q = _trading()
+    rs = _result(g, inv, {"acf1": {"value": -0.100}, "boot_ci_lo": {"value": -0.144}, "boot_ci_hi": {"value": -0.048}})
+    g.create(author="quant", type="claim", inv=inv, fields={
+        "statement": "The lag-1 autocorrelation is -0.100 and its bootstrap 95% CI [-0.144, -0.048] excludes zero.",
+        "scope": "bars.csv, days 0-1499.",
+        "measurements": [{"name": "acf1", "key": "acf1", "result": rs}, {"name": "lo", "key": "boot_ci_lo", "result": rs},
+                         {"name": "hi", "key": "boot_ci_hi", "result": rs}]},
+        links=[{"rel": "answers", "to": q}, {"rel": "derived_from", "to": rs}])

{hypgraph-0.7.0 → hypgraph-0.7.1}/tests/test_workflows.py

@@ -89,7 +89,7 @@ def test_scientific_stage_is_read_off_the_record():
                  "success_criteria": "every fixture parses"},
                  links=[{"rel": "tests", "to": h, "data": {"expected": "all 9 fixtures parse"}}])["id"]
     assert _stage(g, q) == ("run", 4, False)
-    run = g.create(author="w", type="run", inv=inv, fields={"kind": "agent", "name": "parse", "state": "succeeded"},
+    run = g.create(author="w", type="run", inv=inv, fields={"kind": "agent", "name": "parse", "state": "succeeded", "config": {"source": "print('parse')"}},
                    links=[{"rel": "executes", "to": x}])["id"]
     assert _stage(g, q) == ("evidenced", 5, False)
     rs = g.create(author="w", type="result", inv=inv, fields={"summary": "Parsed 9 of 9 trailing-comma fixtures.",
@@ -192,7 +192,7 @@ def test_uses_is_at_risk_only_under_a_workflow():
     for pid, expect in (("scientific@1", False), ("scientific@2", True)):
         g, inv, q = _g(pid)
         data = g.create(author="w", type="artifact", inv=inv, fields={"sha256": SHA_C, "path": "data.csv", "kind": "data"})["id"]
-        run = g.create(author="w", type="run", inv=inv, fields={"kind": "agent", "name": "fit", "state": "succeeded"},
+        run = g.create(author="w", type="run", inv=inv, fields={"kind": "agent", "name": "fit", "state": "succeeded", "config": {"source": "print('fit')"}},
                        links=[{"rel": "uses", "to": data}])["id"]
         rs = g.create(author="w", type="result", inv=inv, fields={"summary": "Fitted the model on the data file.",
                       "values": {"rmse": {"value": 0.41}}, "outcome": "positive"}, links=[{"rel": "produced", "from": run}])["id"]
@@ -205,7 +205,7 @@ def test_uses_is_at_risk_only_under_a_workflow():
 # ── trading ────────────────────────────────────────────────────────
 
 def _bt(g, inv, author, values, summary="Backtested the thesis out of sample.", q="", x=""):
-    r = g.create(author=author, type="run", inv=inv, fields={"kind": "agent", "name": "backtest", "state": "succeeded"},
+    r = g.create(author=author, type="run", inv=inv, fields={"kind": "agent", "name": "backtest", "state": "succeeded", "config": {"source": "print('backtest')"}},
                  links=[{"rel": "executes", "to": x}] if x else None)["id"]
     links = [{"rel": "produced", "from": r}] + ([{"rel": "part_of", "to": q}] if q else [])
     return g.create(author=author, type="result", inv=inv, fields={"summary": summary, "values": values, "outcome": "positive"},
@@ -260,7 +260,7 @@ def test_trading_trials_positions_and_no_live_orders():
 
 def test_valid_until_makes_a_result_stale():
     g, inv, _q = _g("trading@2")
-    r = g.create(author="quant", type="run", inv=inv, fields={"kind": "agent", "name": "backtest", "state": "succeeded"})["id"]
+    r = g.create(author="quant", type="run", inv=inv, fields={"kind": "agent", "name": "backtest", "state": "succeeded", "config": {"source": "print('backtest')"}})["id"]
     rs = g.create(author="quant", type="result", inv=inv, fields={"summary": "Backtested the thesis out of sample.",
                   "values": {"oos_return": {"value": 0.08}, "fees": {"value": 0.002}}, "outcome": "positive",
                   "valid_until": "2020-06-30"}, links=[{"rel": "produced", "from": r}])["id"]
@@ -311,7 +311,7 @@ def test_optimization_instance_verifier_and_changed_instance():
     inst = g.create(author="lead", type="artifact", inv=inv, fields={"sha256": SHA_A, "path": "instances/40-site.json", "kind": "instance"},
                     links=[{"rel": "part_of", "to": q}])["id"]
     assert _stage(g, q) == ("modelled", 2, False)
-    run = g.create(author="solver", type="run", inv=inv, fields={"kind": "agent", "name": "cbc", "state": "succeeded"},
+    run = g.create(author="solver", type="run", inv=inv, fields={"kind": "agent", "name": "cbc", "state": "succeeded", "config": {"source": "print('cbc')"}},
                    links=[{"rel": "uses", "to": inst}])["id"]
     rs = g.create(author="solver", type="result", inv=inv, fields={"summary": "Solved the model to a 0.0 gap.",
                   "values": {"objective": {"value": 412.0}, "feasible": {"value": True}, "gap": {"value": 0.0}}, "outcome": "positive"},
@@ -508,7 +508,7 @@ def test_an_edit_elsewhere_on_the_page_keeps_the_source_fresh():
 def test_a_decision_on_stale_evidence_and_a_check_of_a_stale_solve_do_not_count():
     g, inv, q = _g("trading@2", reviewers=("risk",))
     data = g.create(author="quant", type="artifact", inv=inv, fields={"sha256": SHA_A, "path": "prices.csv"})["id"]
-    run_ = g.create(author="quant", type="run", inv=inv, fields={"kind": "agent", "name": "backtest", "state": "succeeded"},
+    run_ = g.create(author="quant", type="run", inv=inv, fields={"kind": "agent", "name": "backtest", "state": "succeeded", "config": {"source": "print('backtest')"}},
                     links=[{"rel": "uses", "to": data}])["id"]
     rs = g.create(author="quant", type="result", inv=inv, fields={"summary": "Backtested the thesis out of sample.",
                   "values": {"oos_return": {"value": 0.08}, "fees": {"value": 0.002}, "trials": {"value": 1}}, "outcome": "positive"},
@@ -526,7 +526,7 @@ def test_a_decision_on_stale_evidence_and_a_check_of_a_stale_solve_do_not_count(
     g2, inv2, q2 = _g("optimization@2", reviewers=("verifier",))
     inst = g2.create(author="lead", type="artifact", inv=inv2, fields={"sha256": SHA_A, "path": "instance.csv", "kind": "instance"},
                      links=[{"rel": "part_of", "to": q2}])["id"]
-    r2 = g2.create(author="solver", type="run", inv=inv2, fields={"kind": "agent", "name": "solve", "state": "succeeded"},
+    r2 = g2.create(author="solver", type="run", inv=inv2, fields={"kind": "agent", "name": "solve", "state": "succeeded", "config": {"source": "print('solve')"}},
                    links=[{"rel": "uses", "to": inst}])["id"]
     s2 = g2.create(author="solver", type="result", inv=inv2, fields={"summary": "Enumerated the instance.",
                    "values": {"objective": {"value": 40}, "feasible": {"value": True}, "gap": {"value": 0.0}}, "outcome": "positive"},