The Black is not dice: developer statements, evidence report, and a plan that looks for the rule

- planner/knowledge.yaml: what the game's developer has said (paraphrased, dated, graded), what the Atlas does
  with each statement, and the open questions with the experiment that tests each.
- analysis/black/evidence.py -> analysis/reports/BLACK.md: counts from the runs. On the same recorded route the
  shadow shows on 21 of 79 first attempts and 1 of 80 later ones; no single route; Blue then Black after the shadow.
- game.yaml: the shadow is a guard (not a roll); what follows it is the Blue, then the Black; on-screen text for
  the squad's direction screen.
- planner/experiments.yaml v2: one exact path on every fresh account (fresh-replicate), then one choice changed
  at a time (fresh-ablate); shadow-again, second-attempt-same-path, veteran-repeat, veteran-variety; what the bot
  records about the account; the sequence to follow once the shadow shows.
- solver.js: assign() takes account facts, account offsets and cycled arms; recommendOption() answers the
  squad screen (stay + direction) in one pick.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014jqCC2LZ4x1WHQ1V57nTsv
This commit is contained in:
ekcSchiano
2026-11-16 15:24:03 +00:00
co-authored by Claude Fable 5.2
parent 51842e1aa9
commit d01ec46fcc
19 changed files with 1588 additions and 231 deletions
+38 -11
View File
@@ -5,10 +5,18 @@ The Atlas side is done (branch `first-attempt-cycle`). This is the bot's side. D
## Why
In the community form, the shadow shows on 9% of first attempts at the tree and 0.3% of later ones (69 in 748
against 7 in 1,995, the same in every week). The bot has 236 tree runs and no shadow, all on attempt 2 or later;
it has never logged a first attempt. So: every new account's first attempt is the Black attempt, and it is also
the experiment that measures the first-attempt rate without reporting bias.
Two things changed the plan (16 November).
**The developer says the Black is not dice** (`planner/knowledge.yaml`). The seed plays no part in whether it shows:
it shows when the rider's choices meet its conditions, and a rider who knows them bonds with certainty. There is no
single route; the bullies encounter and the tree are gates; there are a handful of conditions, not dozens.
**The runs say it is close to a first-attempt event** (`analysis/reports/BLACK.md`). On one and the same recorded
route, riders report the shadow on 21 of 79 first attempts and 1 of 80 later ones. The bot has 236 tree runs and no
shadow, all on attempt 2 or later; it has never logged a first attempt.
So the bot stops estimating a rate and starts looking for the rule: one exact path on every fresh account, then
one choice changed at a time. If the answer is not dice, a few accounts per question are enough.
## The five changes
@@ -19,7 +27,7 @@ the experiment that measures the first-attempt rate without reporting bias.
then:
```js
const a = Solver.assign(plan, { accountSeq, attempt }); // what this attempt is for
const a = Solver.assign(plan, { accountSeq, attempt, facts: { sawShadowBefore } }); // what this attempt is for
const adv = Solver.advisor(policy.samples.all, a.target, a.objective,
{ attempt, fix: a.fix, sampling: a.sampling, seed: a.seed });
```
@@ -27,7 +35,7 @@ the experiment that measures the first-attempt rate without reporting bias.
and log `experimentId`, `arm`, `planId`, `policyId`, `accountAttempt` and the propensity on the run. Never
reload the kit in the middle of an attempt.
4. **The account's life** (`plan.lifecycle`): attempt 1 is the Black attempt; then three days of research
attempts; then retire the account, except when `accountSeq % 10 === 0` (those keep running).
attempts; then retire the account, except when `accountSeq % 10` is 0 or 1 (those keep running).
5. **Run the cycle on a timer** on the bot's machine, from a clone of the Atlas:
```
@@ -44,10 +52,29 @@ the experiment that measures the first-attempt rate without reporting bias.
| Attempts | Experiment | What the bot does |
|---|---|---|
| 1 | `first-attempt-shadow` | Investigate, help, tree. Direction and fork are West or East by arm (4 arms, 60 accounts each). Burn when there is no shadow; bond a Black. |
| 2 (half the accounts) | `attempt-2-shadow` | The same tree run once more, to check the shadow is gone. |
| 2 onward, 60% | `meadow-blue-route` | Go to the meadow; investigate or keep walking, and the first direction, by arm (6 arms, 70 each). Burn unless a Blue waits. |
| 2 onward, 25% | `mapping` | Pick at random among the options on each screen (`recommendOption` does it). |
| 2 onward, 15% | `sentinel` | One fixed route, to notice if the game's odds change. |
| 1 | `fresh-replicate` (60 accounts) | One exact path: alone, west, hold still, investigate, help, pause to assess, engage the smaller cadet, squadmate's revenge, fork west, tree. Burn when there is no shadow. |
| 1, afterwards | `fresh-ablate` (12 arms, 15 accounts each) | The same path with one choice changed. Starts by itself when the replication is complete. |
| 2 to 4, accounts that saw the shadow and died | `shadow-again` | The same path again. |
| 2, half of the other accounts | `second-attempt-same-path` | The same path again. |
| 3 onward, one account in ten | `veteran-repeat` | The same path on every attempt, indefinitely. |
| 3 onward, one account in ten | `veteran-variety` | A different combination of company, direction, fight, fate and fork on every attempt, both gates kept. |
| 2 onward, the rest | `meadow-blue-route` 50%, `mapping` 35%, `sentinel` 15% | As before. |
`assign()` now takes the account's facts: `Solver.assign(plan, { accountSeq, attempt, facts: { sawShadowBefore } })`.
## When the shadow shows
The bot has never seen these screens, so `experiments.json` carries the sequence riders report for a bonded Black
(`plan.scripts.shadow`): for each screen in order, a pattern for the option to take and one for options never to
take. In riders' notes, approaching the Blue or warning the other cadet has always been fatal, lowering your eyes to
the Black has never bonded (0 of 7), and holding its gaze bonded 27 of 39. Where a screen matches nothing in the
script, stop and notify a person: do not guess. Log every screen, its options and the pick; the 12 failures while
holding its gaze are unexplained, and the screens before it are where the explanation should be.
## What to record about the account
`plan.record` lists it: `accountSeq`, `accountAttempt`, `accountCreatedAt`, the cadet's `wing`, `section` and
`squad` as the site shows them, and `sawShadowBefore`. If identical paths on fresh accounts disagree about the shadow,
the difference is something the site knows about the account, and these are the candidates we can see.
The plan updates itself from the runs: a finished experiment stops being assigned and its share goes to the others.
+6 -2
View File
@@ -37,7 +37,7 @@ opens the pull request with the new data.
const plan = require('../vendor/threshing-atlas/experiments.json');
// accountSeq: the account's number in the order accounts were made (0, 1, 2, ...), fixed for its life
// attempt: the account's attempt number (1 = its first threshing)
const a = Solver.assign(plan, { accountSeq, attempt });
const a = Solver.assign(plan, { accountSeq, attempt, facts: { sawShadowBefore } });
// -> { experimentId, arm, fix, target, objective, sampling, seed, propensity, burn, planId } (null: no experiment)
const advisor = Solver.advisor(policy.samples.all, a.target, a.objective,
{ attempt, fix: a.fix, sampling: a.sampling, seed: a.seed });
@@ -54,7 +54,11 @@ const advisor = Solver.advisor(policy.samples.all, a.target, a.objective,
- `burn` names the deliberate-burn rule the experiment expects (`TREE_NO_SHADOW_AUTO_BURN`,
`MEADOW_NO_BLUE_AUTO_BURN`). A genuine Black or Blue bond is always accepted.
- The account's life (`plan.lifecycle`): attempt 1 is the Black attempt; then about three days of research
attempts; then the account retires, except one in ten, which keeps going so that late attempts are observed.
attempts; then the account retires, except two in ten, which keep going (one repeating a path, one varying it).
- `plan.record` lists what to log about the account on every run; `plan.scripts.shadow` is the sequence to follow
once the shadow shows (`docs/BOT_CYCLE_FOR_KEN.md`).
- With squadmates, staying together and the direction are one screen; `recommendOption()` answers both at once
and says so in `also`.
An experiment that reaches its planned count becomes `complete`, one that meets its stopping rule becomes `paused`;
either way `assign()` stops giving it out and its share goes to the others. Nothing in the bot changes.
+24
View File
@@ -285,3 +285,27 @@ Branch `first-attempt-cycle` (not merged, not pushed).
the bot that is running, so the bot's side was written as a specification, not against its code.
- **Not done:** the page does not show first-attempt odds yet; Gitea still needs Kathleen's account, the
repository and the push (`docs/REPO_SETTINGS.md`); git.kenschiano.net answers (Gitea 1.27.0).
## 11. Update, 2026-11-16: the developer's statements, and looking for the Black's rule
- **Source.** The developer's answers in a community Discord channel (135 forwarded messages, exported
2026-11-16). The export is private raw data; `planner/knowledge.yaml` holds the statements paraphrased, dated and
graded (said / hint / declined), with what the Atlas does with each and the open questions.
- **What it changes.** The Black is not dice: the seed plays no part, it shows when the rider's choices meet its
conditions, and knowledge gives certainty. The bullies encounter and the tree are gates; there is no single route;
about five conditions. The Blue is dice from the seed. No event is rarer than 1 in 20. Runs are never forgotten
and never hurt.
- **What the runs add** (`analysis/black/evidence.py` -> `analysis/reports/BLACK.md`, rebuilt every cycle): on the
same recorded route, 21 of 79 first attempts show the shadow against 1 of 80 later ones (across routes: odds ratio
21.5, z = 9.8); on that route, runs with the same wing, section and squad still disagree; shadows are on 44
different recorded routes; after the shadow comes a Blue, then the Black; holding the Black's gaze bonded 27 of
39, lowering eyes 0 of 7.
- **Model.** The shadow is marked `guard: true` in `game.yaml`: the model's number is the share of runs that met
unknown conditions, not a chance. `shadowColour` is "past the Blue to the Black".
- **Plan (version 2).** Attempt 1 on every fresh account is one exact path (`fresh-replicate`, 60 accounts), then
one choice changed at a time (`fresh-ablate`, starts by itself). `shadow-again`, `second-attempt-same-path`,
`veteran-repeat` and `veteran-variety` test fresh against veteran. `assign()` takes account facts; the plan carries
what to record and the sequence to follow once the shadow shows.
- **Not known.** What differs between fresh accounts that see the shadow and those that do not on the same route;
what "twenty" counts; why holding the Black's gaze fails three times in ten.
- **To tidy.** One public `bond_note` holds a rider's handle ("Run 116 - ..."), in a row marked as a first attempt.