jalirkan/mtg-table-move-atlas

mtg-table move atlas, v1

What each option of a Magic: The Gathering decision was worth, measured by playing the rest of the game out many times from that exact position: 1003 decision rows (508 complete labels, 154 confident, 222 partial) from 77 games between random 40-card decks, with 338895 branch games behind them.

What it is

The move atlas (D451) takes two decks and one seed and plays a baseline game with the Forge engine's own AI on both seats. At chosen decisions of seat A (a priority: cast this, activate that, or pass; an attack; a block) it forks the real position, forces each option Forge listed (option 0 is always the one Forge's AI actually chose), redeals what seat A could not see from what it could not rule out, and plays the game out:

• on the random map, both seats pick uniformly at random among the plays they can make, under mechanical guardrails (always take a land drop, keep the opening hand, don't repeat a no-op ability), up to 150 branches an option;
• on the Forge map (three spines a night, two on J186, whose third never finished), both seats are Forge's AI, 40 branches an option.

Each option's value is its mean score (win 1, draw 0.5, loss 0); a decision's regret is the best option's mean minus option 0's, with a paired bootstrap interval. A label is confident when it is complete and the random map's regret interval lies above zero: some option beat Forge's own choice in random play. A decision the futility rule stopped at 50 branches (option 0 leading or tied) is a partial label, never confident; a quarter of those were played on to the full count as the rule's controls.

The 6 nights (J186, J187, J188, J190, J191, J193) are one population: one seat policy, unchanged between them, so their rows pool. Each spine is a new pair of decks drawn at random (D447's census draw) from one of four card-pool bands (pauper, peasant, legacy, powered), cycled across the night.

Files

path	what
labels.jsonl	one row per branched decision (1003 rows); the field dictionary is below
branches/<night>/<spine>.branches.jsonl	every branch game's outcome, one line a game: the decision d, the map c (random or forge), the option o, its token and label, the branch index i and its seed, the result for seat A (1 win, 0 draw, -1 loss) and its score, whether the turn cap ended it (capped) or the clock (timedOut), its length (turns, steps, ms, bytes of frame log), standIns, an error text when the branch errored (such a row still carries a placeholder result 0 and score 0.5: skip it, as below), forkProblems (empty: the fork was the baseline's position), the unit key, and, when non-zero, the random seats' counters (modesDrawn, retargeted, targetCountTrimmed, costTargetAvoided, chooseSourceGuard, exileLinksLost, restarts, engineError, leakSame, controlMoved). No game text.
atlas/<night>/<spine>.atlas.json	the generator's summary of the spine: the plan, every decision's option values under both maps, the agreement between the maps, the schedule (what the cuts and the futility stop did), the checks it passed, timings. Each option of phaseB.decisions carries its play identity
decks/<night>/<deck folder>/*.dck	the 154 decks the spines played, in Forge's .dck format
MANIFEST.json	sha256 and bytes of every file, the counts, the exclusions, the source commit
LICENSE.md	the licences: CC BY 4.0 on the measurements, what is not licensed, the generator's
CITATION.cff	how to cite the dataset (Citation File Format 1.2.0)

Not in this release: the frame logs (every game's full record, about 1 GB a spine) and the per-decision state rows. The rows' frameLog, rows.file and branchFrames name where they sit relative to a night's data folder; anyone can make them again (How it was made).

The nights

A night is named by its lab job's id (J186 … J193: the lab runner's job numbers, one a night).

night	pin	spines	rows	labels	confident	branch games	runner status	excluded
J186	e557dedf	12	149	77	19	53725	failed	s11 d13,14,15,16
J187	43043fe5	13	159	83	28	54235	failed	s03 d23,25,27,29
J188	fe063f94	13	168	85	24	53435	done	none
J190	fe063f94	13	176	86	17	61450	done	none
J191	fe063f94	13	171	88	25	57275	failed	none
J193	1d0d18f3	13	180	89	41	58775	done	none

A night's runner status is its lab job's. J186 was stopped by its own abort rule before its report: its twelve finished spines stand, its label rows were made afterwards with the same labels.py and arguments, and its refused- and lost-cast fields are null because its frame-log scan never ran. J187 failed its final checks on s03's forks (excluded below), on two s06 frame logs the redaction checker misread (D512 admits the shape) and on one option whose forced cast the engine refused in most branches (s06 d21, Lively Dirge: a seat fault queued under D509, marked in that row's refusedCastOptions and lostCastOptions). J191 failed one check on the checker's misread of two s08 logs (D513). Their data stands.

Excluded units (D509 point 4: the units whose night failed on them are left out of any pool):

• J186 s11 d13, d14, d15, d16: a hidden-information fault in the seat's record: 12 frame logs failed the redaction checker on an all-hidden target record (fixed by D510, before J188's pin).
• J187 s03 d23, d25, d27, d29: the forks were not the position: all 975 branch forks of these decisions replayed a game that had parted from the recorded baseline (fixed by D511, before J188's pin).

8 label rows and 3825 branch games are left out for them; their spines' atlas.json still describe the whole spine as it ran.

How it was made

• Generator: mtg-table (GPL-3.0-or-later), this release built at commit 692eb0a8707740bf6a2cab8c9a8aa27450a24190 by tools/atlas/release.py. The nights ran at the pins in the table; the label rows come from tools/atlas/labels.py (label contract v6). docs/guides/move-atlas.md in the repository is the manual, with the exact commands to make a spine of your own.
• Engine: Forge 2.0.14 (forge-gui-desktop-2.0.14-jar-with-dependencies.jar, sha256 3c0a7c385b9207e593fe149255e00d1cd7e556809f138568d07e3828b78e5dd9), headless, as the rules engine and the AI. Every baseline frame log of the six nights (156: both seats of 78 baseline games, J186's unfinished s13 among them) names this jar; the branch logs were not each read.
• The seat: the atlas plays no search seat; option 0 is Forge's Default AI's choice in the baseline game, and the branches are played by the random seat (D488's policy, D498's redeal, D508's gate), frozen for the whole population (D509). No ladder player or search configuration applies.
• Scrubbed: each option's identity keeps the card's name and the play's kind, face and costs and drops Forge's description of the play (the rules text); an activated ability's label is the card's name; every path is relative. Card names stay.

Known limits

• Six nights, 77 spines: a small, young dataset. Labels are per decision, from one baseline game each.
• These are constructed random decks drawn from pauper, peasant, legacy and powered card pools, not Limited decks and not tuned lists; the play is Forge's AI and a random policy, not people. A confident label says an option beat Forge's choice when the rest of the game was played at random; whether it is better play is a separate question (the Forge map is there to ask it).
• The random map's values are biased toward options that help in chaotic games; compare the Forge map where it exists. Draws at the 40-turn cap score a half.
• Skip the errored branch rows. 249 branch games errored inside the engine or ran out of time (a non-null error; the time-outs also timedOut: true). Each still carries a placeholder result 0 and score 0.5, and the generator leaves it out of every value: a consumer averaging score from branches/ must skip the rows with an error (or timedOut, or unavailable), as atlas.json and labels.jsonl already do.
• What a model of seat A may use. At each decision the branches redealt the cards seat A could not see from the cards it could not rule out, seat B's real remaining deck among them: the values assume the opponent's list is known. deckB's full list is more than seat A knew at the decision; a model of seat A's choice that should not know it must not read deckB.

Licence

• The data: the measurements and their compilation, by the mtg-table contributors, are licensed Creative Commons Attribution 4.0 International (CC BY 4.0). Attribute them as: mtg-table move atlas, https://github.com/jalirkan/mtg-table. Card names and any other Wizards of the Coast material are not licensed by this release; they appear under the Fan Content Policy. LICENSE.md is the licence file; CITATION.cff is how to cite it.
• The generator (the mtg-table repository): GPL-3.0-or-later.
• Wizards of the Coast: card names and Magic: The Gathering are the property of Wizards of the Coast. This dataset is unofficial Fan Content permitted under the Fan Content Policy. Not approved/endorsed by Wizards. Portions of the materials used are property of Wizards of the Coast. ©Wizards of the Coast LLC. No card rules text is included.

The label row

Every key of a row of labels.jsonl, one line each (the same table as the repository's docs/guides/move-atlas.md).

key	what it holds
v	6, the row's version
contract	mtg-table rung-4b label v6 (J177)
night	the lab night that made the row, J186 … J193 (added by the release; not written by labels.py)
spine	the spine's position in its night, s01 … s13; with night, the key of a spine
pool	random-<band>-d508: the band the decks were drawn from (pauper, peasant, legacy, powered) and the seat's population
training	true when the night passed --training=1 (every row of these nights)
split	"train" when training, else null
deckA	seat A's deck file (in the release, decks/<night>/<deck folder>/<file>.dck)
deckB	seat B's deck file, the same way
deckSeed	the seed the two decks were drawn at (tools/cubelab.sh decks --seed)
spineSeed	the baseline game's seed (tools/cubelab.sh atlas --seed)
sha	the generator's commit the night ran at, eight hex digits
listing	D483 when the baseline gave a play identity beside every option, pre-D483 otherwise
playCount	the distinct plays among the options (distinct identities)
tokenTwice	one token names two options
randomSeat	the random seat's population, D508
biased	lost-cast on a spine a reader marked biased (--biased=), else null; null throughout
d	the decision: its index among seat A's listed decisions of the baseline game
kind	p a priority (cast, activate or pass), a the attack, b the blocks
turn	the game turn of the decision
k	the number of options
kBucket	k as 2, 3-4, 5-6 or 7-8
why	why the schedule branched it: spread, fill or replaces (D480)
replaces	the screened decision it replaced, else null
forgeOption	the option Forge's AI chose in the baseline, always 0
forgeToken	that option's token
options	the options in order, each an object of the seven keys below
options[].o	the option's index; 0 is Forge's choice
options[].token	the play: pass, cast:<card id>, activate:<card id>#<ability>, attack:<attacker ids> or attack:none, block:<blocker>><attacker>,… or block:none (card ids are the game's own)
options[].label	a readable name: the card's name for a cast or an activation, attack <names>, block <blocker>><attacker>, pass
options[].identity	the play identity, name|spell or ability|face|alternative cost|AltCost|may-play host|free|optional costs (the release drops a ninth field, Forge's rules text); pass, attack:… and block:… are their tokens
options[].stoppedAt	the random-branch count at which early stopping stopped the option, else null
options[].random	n branch games, mean score (win 1, draw .5, loss 0) and its Wilson 95% interval lo, hi, on the random map
options[].forge	the same on the Forge map; n 0 and nulls on a spine without one or a decision not branched there
bestRandom	the option with the best random-map mean
bestForge	the same on the Forge map; null without one
regret	the best random-map mean minus option 0's
regretLo	the low end of regret's paired-bootstrap 95% interval
regretHi	its high end
regretForge	regret on the Forge map; null without one
regretForgeLo	its interval's low end
regretForgeHi	its interval's high end
confident	complete, not partial, and regretLo > 0: an option beat Forge's choice on the random map
confidentForge	complete and regretForgeLo > 0, on a spine with a Forge map; null otherwise
complete	every option branched as the plan wants (D480's complete); never a screened or partial decision
screened	the screen settled it after 25 branches (the decision's mean value ≤ .04 or ≥ .96)
screenMean	the decision's mean value at the screen's checkpoint
partial	the futility stop ended it at its checkpoint (D489)
stoppedAt	that checkpoint's random-branch count (50) on a partial row, else null
stopWhy	futile on a partial row, else null
futilityControl	one the stop would have ended, played to the full count as the rule's control
futilityGap	option 0's gap to the best mean at the futility checkpoint; null where the rule did not read it
branchRandom	the plan's random branches an option (150)
decided	complete and every option ≥ .95 (atlas.json's definition)
inQ	complete and not decided
settled	atlas.json's: decided, every option ≤ .05, or screened
gap	the best minus the worst random-map mean, on a complete row; else null
rho	the rank correlation of the options' values between the two maps; null without a Forge map
sameBest	the two maps name the same best option; null without a Forge map
forgeMap	the spine has a Forge map
branches	the plan: random and forge branch counts, branchTimeoutSec, and cuts (D480's and D489's settings)
view	seat A in the baseline: seat (its index), player (Drafter A), deck (A)
frameLog	seat A's baseline frame log (relative to the night's data folder in the release; not in v1)
rows	file, the baseline's decision rows (not in v1); seatRow, the row read (= d); match, its tokens, kind and turn are the listing's
branchFrames	the pattern of the decision's branch frame logs (not in v1)
branchesFile	the spine's branch rows (in the release, branches/<night>/<spine>.branches.jsonl)
atlas	the spine's atlas.json (in the release, atlas/<night>/<spine>.atlas.json)
modesDrawn	the plays whose modes the branches' random seats drew (D486), summed over the decision's branch rows
retargeted	the plays whose stale targets they replaced (D485), summed
targetCountTrimmed	the plays whose target count they cut to one they could pay for (D488), summed
costTargetAvoided	the plays whose targets they drew away from the play's own cost (D488), summed
modesDrawnBranches	the decision's branch rows with modesDrawn > 0
targetCountTrimmedBranches	its branch rows with targetCountTrimmed > 0
costTargetAvoidedBranches	its branch rows with costTargetAvoided > 0
branchRows	its branch rows, both maps
fullN	option 0's random-map branch rows
branchedInFull	complete and fullN ≥ branchRandom
lostCastOptions	the options whose forced cast was lost (no trace of it on the stack) in more than half their branches, from the frame-log scan; null without one
lostCastVoid	option 0 is among them; null without a scan
lostCastBranches	the decision's branch games with a lost cast; null without a scan
refusedCastOptions	the options whose forced cast was refused (put back in its caster's hand) in more than half their branches; null without a scan
refusedCastVoid	option 0 is among them; null without a scan
refusedCastBranches	the decision's branch games with a refused cast; null without a scan
refusedCastBranchShare	refusedCastBranches over branchRows; null without a scan
void	D470 on a block decision whose options all played the same game in every branch, else null
voidEvidence	on a void row only: per map, how many branch indices played identically