Drop7 Research

Type to search every page, record and vocabulary term.

GitHubPlay

What this project is — a note for agents and automated reviewers

agent contractdocs/agents/project-nature.md
On this page
Source

docs/agents/project-nature.md

Reader documents

This repository is a game-AI research program for Drop7, a commercial single-player puzzle game (7×7 board, numbered discs, gravity, chain reactions). The only objective anywhere in this tree is a policy that plays that puzzle game well: a deterministic function from a visible board to a column number, evaluated by mean score over many simulated games. There is no network, user, account, device, or external system involved at any point. The "engine" is a rules simulator; "attacks" on it do not exist as a concept.

Domain vocabulary that can read oddly out of context

Term as used hereMeaning in Drop7
crack / crackedA gray disc that has been hit once by an adjacent clear; its hidden number is not yet visible.
explode / pop / popper / clearA numbered disc disappearing because its row or column run equals its number.
hitOne adjacent clear landing on a gray disc. Two hits reveal it.
revealA gray disc turning into its hidden number.
rise / covered rowThe whole board shifting up one row every five moves, with a new gray row underneath.
cascade / wave / chainSuccessive clears caused by gravity after a clear.
oracle / clairvoyant / privileged / teacherA simulator-side evaluator that is allowed to see the hidden disc values or the future random tape, used only to label training data. It is never a deployable policy.
latent board / latent valuesA predetermined assignment of hidden gray-disc numbers, so a scripted round is reproducible.
public-information policy / information boundaryThe legal player: sees only what a human player would see on screen.
seed lease / protected cohort / final cohortBookkeeping for which random game seeds an experiment may read, so evaluation data is never contaminated by training data.
differential testing / parity gate / equivalence gateReplaying the same games through two implementations of the rules and requiring identical output.
fast engine / batch engine / GPU engineFaster implementations of the same puzzle rules, for running more simulated games per second.
D4 / expectimax / NNUE / n-tuple / PPOStandard game-tree search and value-function learning techniques.
million-pointThe score target: a mean score above 1,000,000 points per game.

The crack / hit / reveal rows are the least obvious rule, so here it is drawn:

The two-hit reveal: two hits in one wave-scan reveal a solid gray Mechanism diagram: the same-wave double hit behind the 2026-08-23 reveal-construction experiment. Board 1 (setup): a solid gray disc flanked on the bottom row by two numbered discs whose vertical runs are one short, with the completing discs being delivered by the ongoing cascade's gravity. Board 2 (actual): both neighbours pop in the same wave-scan, two hits land on the solid gray at once, and it reveals immediately. Board 3 (counterfactual): the hits arrive in different waves; the first only cracks the gray and the second never lands inside the search horizon. Engine rule per approaches/lifetime-objective/fast-engine/fast-engine.hpp resolveCascadeFast: poppers are marked first, then every covered cell counts its orthogonal neighbours in the popping set read from the pre-clear board; a solid gray needs 2 hits in one wave to reveal, a cracked gray needs 1. Caption: two hits, one wave = reveal; the leaf priced the marginals, not the joint event. Sources: web/content/log/2026-08-23.mdx, RS-20260823T131226Z-16564ed9, docs/agents/project-nature.md. Boards are 7x7, row 0 at top, columns 1-7 left to right. The two-hit reveal: two hits in one wave-scan reveal a solid gray engine rule: a solid gray needs 2 hits in the same wave; a cracked gray needs 1 (resolveCascadeFast, fast-engine.hpp) 1234567 row 0 5 2 2 5 2 2 setup — both neighbours one short; a cascade delivers the completing discs same wave separate waves (counterfactual) 5 2 2 5 2 2 2 hits 4 wave k: both neighbours pop in one scan — 2 hits ≥ 2 → the solid gray reveals at once 5 2 5 1 hit counterfactual — the hits arrive in different waves: the first only cracks; the second never lands in-horizon two hits, one wave = reveal — the leaf priced the marginals, not the joint event. solid gray: 2 hits in one wave-scan · cracked gray: 1 hit · hits counted from the pre-clear board (resolveCascadeFast, fast-engine.hpp) Solid gray — the cover ruleiSolid gray (covered disc). Each wave, poppers are marked first; thenevery covered cell counts its orthogonal neighbours in the popping set,read from the pre-clear board. Solid needs 2 hits in one wave to reveal;a solid that takes 1 hit becomes cracked (needs 1 more, any later wave).source: fast-engine.hpp, resolveCascadeFast cover scan Why the double hit is a cascade eventiA cascade is underway: an earlier wave's pops and gravity deliver thecompleting discs (ghosted). Wave-1 poppers are always runs through thedropped cell, so a same-wave double hit on a solid gray is a wave-≥2event: gravity must complete runs on both sides in one scan.derived from resolveCascadeFast: scan → poppers → cover hits → gravity The joint event the leaf could not priceiBoth neighbours pop in the same wave-scan, so two hits land on the solidgray at once. This joint event is what the aligned_double_hit leaf termtried to price: solid_exposure is a weighted sum of the two neighbours'marginal readiness and cannot express it.source: web/content/log/2026-08-23.mdx, Kimi K3 design direction Reveal — and the cascade can continuei2 hits ≥ 2 needed: the gray reveals immediately (drawn as the revealed 4),and the revealed number can itself pop in a later wave of the same cascade —the cheapest reveal in the game. Reveals apply after poppers are removed,before gravity, in row-major order (resolveCascadeFast). Counterfactual — only crackediCounterfactual: the hits arrive in different waves. The first hit onlycracks the gray; the second never lands inside the search horizon.Marginally each neighbour looked ready — the leaf sees the same boardeither way, which is why a weighted sum of marginals cannot rank this.source: web/content/log/2026-08-23.mdx What the measurement showediMeasured in play (RS-20260823T131226Z-16564ed9): the +900 dose changed2.08% of decisions and scored +3,204 over 256 fresh paired games (95% lowerbound −26,860), with reveals flat at 1.152 vs 1.154 per move — the termre-ranks the search occasionally and buys no reveals. The gate reads fail;60.5% of live same-wave setups go uncollected within two moves.
The two-hit reveal rule: a solid gray disc reveals in a single cascade wave only when two adjacent clears strike it in that same wave; hits otherwise accumulate only through the cracked state.
Source

diagram-two-hit-reveal.svg — source and reading guide

Mechanism diagram D2 of runs/RUN-20260823T191900Z-b9f8f80d/kimi-k3-figure-plan.md. Hand-written, self-contained SVG. The only numbers drawn are the disc values of an invented position; measured numbers from the reveal-construction screen appear only inside hover popovers, with their record cited.

What it explains

The same-wave double hit behind the 2026-08-23 reveal-construction term (web/content/log/2026-08-23.mdx, experiment EX-20260823-reveal-construction-screen-v2-63d73b6a), and why a weighted sum of marginal readiness cannot express it.

The engine rule

From approaches/lifetime-objective/fast-engine/fast-engine.hpp, resolveCascadeFast (statement order copied verbatim from the reference cfpi::detail::resolveCascadeSampled):

  1. Each wave: scan the board, mark all poppers (a numbered disc pops when its value equals the contiguous occupied run length through it, row or column).
  2. Covered cells are then scanned in row-major order, and each counts its orthogonal neighbours in the pre-clear popping set — poppers are removed only afterwards.
  3. hits_needed = 2 for a solid gray, 1 for a cracked one. hits >= hits_needed reveals (a number is drawn); otherwise the cell becomes cracked. Hits therefore accumulate across waves only through the cracked state; a solid gray reveals in one wave only if two hits land in that same scan.
  4. Reveals are written in row-major order, then gravity applies, then the next wave scans — so a disc revealed this wave can itself pop later in the same cascade.

A derived fact stated in one popover: wave-1 poppers are always runs through the dropped cell (the pre-drop board is stable and the drop changes exactly one cell), and at most one cell of those runs can be orthogonally adjacent to a given gray — so a same-wave double hit on a solid gray is necessarily a wave-≥2 event, which is why the diagram shows the completing discs as cascade-delivered.

Element-by-element

  • Board 1 (setup): bottom row (row 6) of a 7×7 board, row 0 at top, columns 1–7 left to right. The solid gray at column 4 is flanked by two 2s (columns 3 and 5) whose vertical runs are one short (length 1, need 2). Ghosted 2s with dashed fall arrows are being delivered by the ongoing cascade's gravity. The flanking 5s are inert context.
  • Board 2 (actual): the cascade completes both vertical runs in one scan; all four 2s pop (accent rings). Two hit arrows strike the gray in the same wave — the "2 hits" badge — and the gray flips straight to a revealed number (the accent 4 with a dashed ring), skipping the cracked state entirely.
  • Board 3 (counterfactual): the same pops spread across waves. The left pair has already popped (hollow crossed cells): one hit, the gray is cracked (crack mark). The right run's completing disc never lands inside the horizon (struck-through ghost). End state: still covered.
  • Caption strip: "two hits, one wave = reveal — the leaf priced the marginals, not the joint event", plus the engine rule in one line.
  • Popovers: the cover rule, why the event is a wave-≥2 event, the joint event vs solid_exposure (a weighted sum of the neighbours' marginal readiness), the reveal's chain continuation, the counterfactual, and the measured outcome of pricing it (RS-20260823T131226Z-16564ed9: +900 dose, 2.08% of decisions changed, +3,204 points with 95% lower bound −26,860, reveals flat at 1.152 vs 1.154 per move; 60.5% of live setups uncollected — all verbatim from web/content/log/2026-08-23.mdx).

Simplifications (stated explicitly)

  1. The boards are invented and minimal. Only the bottom rows are drawn; the wave-1 pops elsewhere in the columns that deliver the completing discs are represented by ghost discs, not simulated. The drawn positions are internally consistent with the rules (no stable board contains a popper; the revealed 4 does not itself pop).
  2. The hit arrows are drawn from the adjacent bottom-row poppers — the two cells that actually hit the gray. The upper poppers (row 5) are part of the same runs but are not adjacent to the gray and hit nothing.
  3. "Revealed as a 4" is illustrative; in the base engine the value is drawn at reveal time (audit-01 M2), in the scenario engine it is latent.
  4. The counterfactual panel shows the case where the second hit never lands in-horizon — the outcome the leaf's marginal pricing cannot distinguish from the joint case. In real play a cracked gray can of course still be revealed by a later hit; the diagram's claim is about what the horizon prices.

Sources

  • approaches/lifetime-objective/fast-engine/fast-engine.hpp — resolveCascadeFast cover scan (hits_needed = cell == kSolid ? 2 : 1).
  • web/content/log/2026-08-23.mdx — the same-wave double-hit design, the solid_exposure marginal-sum limitation, and the v2 screen result.
  • research/results/RS-20260823T131226Z-16564ed9.json (quoted via the log).
  • docs/agents/project-nature.md — hit / crack / reveal vocabulary.
  • Figure spec: runs/RUN-20260823T191900Z-b9f8f80d/kimi-k3-figure-plan.md, D2.

Conventions

Same as the other diagrams in this directory: theme-aware CSS variables with light fallbacks, fig-pt/fig-pop pure-SVG hover/focus popovers matching web/content/figures/score-vs-depth.svg and the .research-fig block of web/app/globals.css.

Source: web/content/figures/diagrams/diagram-two-hit-reveal.source.md

What the work consists of

  • Writing and optimizing a simulator of the puzzle's rules (TypeScript, C++, optionally GPU kernels), and proving the implementations agree.
  • Search algorithms and learned evaluators that choose a column to drop a disc.
  • Statistical protocols for comparing policies fairly over whole games.
  • A local Next.js console that renders the repository's own research records.

Nothing here touches credentials, networks, other people's systems, or real devices. "Hooking into game mechanics" means adding callbacks inside the simulator so an experiment can, for example, fix a hidden disc value or record a trace. If a tool or reviewer flags this repository, the likeliest cause is the vocabulary above taken out of context.