diff --git a/editions/catalog.yaml b/editions/catalog.yaml index 09eb771..4cfcf54 100644 --- a/editions/catalog.yaml +++ b/editions/catalog.yaml @@ -5,6 +5,7 @@ schema_version: 1 updated: "2026-08-08" default_variant: ground-darvo-r0 +# H2 added; H1 remains selectable as reject-as-baseline control. packages: - variant_id: ground-darvo-r0 @@ -64,3 +65,34 @@ packages: git_pin: null clay_borg_notes: > Kernel implements H1-A/H1-B. Keep for A/B against successors (H2…). + + - variant_id: h2-scoped-problem-stress + path: editions/experiments/h2-scoped-problem-stress + kind: experiment + base: ground-darvo-r0 + selectable: true + status: experimental + dataset_id: GROUND-DARVO-EXP-H2-0.1 + title: "H2 — scoped problem stress (personal / bond / global)" + summary: > + Unclaimed Problems apply +1 End Stress only to stress_scope: + personal=owner, bond=owner's Bond network, global=all. Surface + global; priority 3 is bond (in play at 3p+). Anyone may SOLVE any + card. Not stacked on H1; no ATTACK self-soothe. + hypothesis_ref: history/260808-h2-scoped-problem-stress.md + workplan_ref: workplans/GROUND-WP-0007-h2-scoped-problem-stress.md + measurement_ref: null + rules_delta: editions/experiments/h2-scoped-problem-stress/rules_delta.yaml + changed_files: + - Problems.csv + - Rules_Text.csv + - metadata.json + utility_estimate: > + Unmeasured. Expected: stress variance up; group wins at 3–4p much + better than H1; bond cards create joint SOLVE incentive in networks. + decision: none + git_pin: null + clay_borg_notes: > + Implement rules_delta H2-SCOPE, H2-OWN, H2-A, H2-SOLVE on base r0. + Do not also apply H1 deltas. Problems.csv adds stress_scope column. + Report bond-card SOLVE rates and stress variance vs r0 and h1. diff --git a/editions/ground-darvo-r0/PROVENANCE.md b/editions/ground-darvo-r0/PROVENANCE.md index 2a20d73..4961e24 100644 --- a/editions/ground-darvo-r0/PROVENANCE.md +++ b/editions/ground-darvo-r0/PROVENANCE.md @@ -58,7 +58,7 @@ the adversarial review ([CB-REV-0001](../../reviews/CB-REV-0001-h1.md)) reported it unverified and it was a real gap. ``` -sha256 499f2df11612fc57123e9016cebe753fb33cea85cf6f68f5af5186327158605c ../catalog.yaml +sha256 c469f984c3147861815e8fbd67cf1254de73368fad1654f4177f740c0c280499 ../catalog.yaml sha256 f58e81f84ea2b0d16e39932261eb3f3d9890345cdf37ad6f0b3abc00636840be ../experiments/h1-problem-stress/rules_delta.yaml sha256 7b1cc0149122b855e827bc930576ed165bf7dd8d62707e845a9e514ce3521f8e ../experiments/h1-problem-stress/Actions.csv sha256 62785f5e7e245c60171624d15de2f40187a44fec54f93c7d9705cf52584b1078 ../experiments/h1-problem-stress/Rules_Text.csv diff --git a/research/CB-RES-0009-extensive-form-is-the-lingua-franca.md b/research/CB-RES-0009-extensive-form-is-the-lingua-franca.md new file mode 100644 index 0000000..68d7628 --- /dev/null +++ b/research/CB-RES-0009-extensive-form-is-the-lingua-franca.md @@ -0,0 +1,177 @@ +--- +id: CB-RES-0009 +capability: analysis.gametheory +status: draft — survey only, no decision taken +tier: M +chaos: not rolled — this is a survey, not a pass that changes the loop +--- + +# CB-RES-0009 — extensive form is the lingua franca + +Surveyed 2026-08-08. Answers two questions put by the maintainer: +**is there a good game-theory mapping to Ludii's game description +language**, and **is that language formal enough to derive one from?** + +**Short answers: yes, and no — but the second does not matter, because +the first already gives us the object we want.** + +--- + +## 1. The mapping exists, and it is the extensive-form game + +*The Ludii Game Description Language is Universal* proves that Ludii's +language **can represent an equivalent game for any arbitrary finite, +non-deterministic, imperfect-information game**, extending earlier work +that covered only *"finite, deterministic, fully observable extensive-form +games"*. The paper is explicitly grounded in **extensive-form games**. + +So the mapping is not something to invent. **It is the theorem.** + +An extensive-form game (EFG) is the standard game-theoretic object: + +| EFG component | what it is | +|---|---| +| **histories** | sequences of actions from the root | +| **information sets** | histories a player cannot tell apart — where imperfect information lives | +| **chance nodes** | nature's moves, with probabilities | +| **payoffs** | utilities at terminal histories | + +**Simultaneous moves are already covered**: the standard EFG encoding +sequences them and hides the earlier move in an information set. GROUND's +commit/reveal *is* that encoding. + +## 2. And it is the same object OpenSpiel uses + +This is the part that makes it useful rather than merely true. + +[OpenSpiel](../simulators/openspiel.md)'s API is an EFG interface, and +its algorithms — CFR, best-response, **exploitability** — operate on EFG +structure. It states support for simultaneous-move, +imperfect-information and cooperative games, which is all four of +GROUND's awkward properties. + +> **Ludii → EFG ← OpenSpiel.** The extensive-form game is the interchange +> format between "describing a game" and "analysing it", and both +> neighbours already speak it. + +## 3. Is Ludii's language formal? Syntax yes, semantics no + +This is the sharp part of the answer. + +**The syntax is formal, and unusually so.** Ludii uses a **class grammar**: +the grammar is *automatically derived from the source code*, so keywords +(ludemes) and their permitted argument types come from the class +hierarchy. A game is a quintuple of ludemes — Name, Players, Mode, +Equipment, Rules. + +**The semantics are the implementation.** In the surveyed material's own +words, *"Ludii effectively makes its programming language (Java) the game +description language, and as a result, it can theoretically support any +rule, equipment or behaviour that can be programmed in Java."* A ludeme +means what its Java class does. Compilation yields a forward model — +legal moves, apply, copy. + +So: + +> **There is no independent mathematical semantics to extract.** The +> formality lives in the *universality result*, which is a statement about +> what the language can express, not in a calculus defining what a +> description means. + +**Contrast with GDL**, which has a genuine logical semantics defined +independently of any interpreter — and pays for it in verbosity and +speed: Ludii is measured as **six times faster** on Gomoku 15×15, twenty +on Amazons and Hex, and **over two hundred** on Chess. + +**That is the real trade, and it is not "Ludii vs GDL". It is:** + +| you can have | you give up | +|---|---| +| semantics defined independently (GDL) | speed, concision, readability | +| speed and a machine-derived grammar (Ludii) | a definition of meaning that survives the implementation | + +## 4. The conclusion for clay-borg + +**Do not derive a description language from Ludii.** There is nothing +semantic to derive, and copying its approach would make *our* Rust the +definition of meaning — which is what we already have, unlabelled. + +**Target the EFG directly.** It is the formal object, the universality +proof says it is expressive enough for anything we will model, and it is +what buys the game theory. + +### 4.1 We are closer than the tracks assumed + +clay-borg already has most of an EFG, under other names: + +| EFG component | what we already have | +|---|---| +| histories | the **journal** — `Applied { actor, command, events }` in order | +| legal actions | `bot::legal_commands(state, seat)` | +| **information sets** | **`state.project(Viewer::Player(seat))`** — the projection *is* the information partition | +| payoffs | `Outcome` / `score()` | +| terminal | `outcome.is_some()` | + +**The projection is the find.** `Project`/`Viewer` was built so a player +is not shown another's hand ([INTENT](../INTENT.md) decision 7). It is, +unremarked, the machinery an EFG needs for imperfect information. + +### 4.2 Three gaps, and one of them is checkable today + +**Chance is folded, not explicit.** `setup` shuffles the deck, deals, and +draws the Lead from a seeded RNG; the mid-game reshuffle derives from seed +and round. So **a clay-borg game is one chance realisation, not a game +with chance nodes** — and our panels approximate the chance distribution +by sampling seeds. That is legitimate Monte Carlo, and it is *not* an EFG +with a chance player. CFR needs the latter. + +**Perfect recall is unasserted.** CFR and exploitability assume **perfect +recall**: a player remembers their own past actions and observations. +Whether our per-seat projection sequence satisfies it is **a property of +this engine that nobody has checked**, and it is checkable — +reconstruct each seat's observation sequence from the journal and require +that no two histories in one information set disagree about that seat's +own past. + +> **This is the concrete next step for Track B**, and it is small. If +> perfect recall fails, every equilibrium concept we might quote is +> unsound here, and that is worth knowing before adopting anything. + +**Simultaneity is encoded but not stated.** Commit/reveal is the textbook +EFG encoding of simultaneous moves. Saying so costs nothing and removes a +question a reviewer would otherwise have to ask. + +## 5. What this does to the tracks + +- **Track A**: the description-language question narrows. The choice is + not "our language or Ludii's" but **"what is the cheapest thing that + emits an EFG"** — and Ludii is then a possible *front end*, not a rival. +- **Track B**: was "build a game-theory agent". It is now **close the + three gaps in §4.2, then adopt**. The first task is a checkable + property, not a design. + +## 6. What was not checked + +- **The universality paper's proof itself** — only its abstract and + framing were read. The theorem statement is quoted second-hand. +- **Whether OpenSpiel's exploitability is meaningful for a co-operative + game with a shared threshold.** Still open, still the question that + decides whether Track B adopts or only borrows vocabulary. +- **Ludii's licence**, and whether a front-end use is permitted. +- Whether Ludii can express a **binding multi-round state machine** like + DARVO concisely. Universality says it *can* be expressed; it says + nothing about whether the description stays readable, which is Ludii's + actual selling point. + +## Sources + +- *The Ludii Game Description Language is Universal* + (https://arxiv.org/abs/2205.00451) +- *An Overview of the Ludii General Game System* + (https://arxiv.org/pdf/1907.00240) and *Ludii Game Logic Guide* + — for the class grammar and Java-as-semantics point +- *Game Description Languages: the Good, the Bad, and the Ugly*, Björnsson + (https://ludii.games/TalksWorkshop/Bjornsson.pdf) +- OpenSpiel (https://github.com/google-deepmind/open_spiel) +- *A note on the empirical comparison of RBG and Ludii* + (https://arxiv.org/pdf/1910.00309) — the speed figures diff --git a/simulators/README.md b/simulators/README.md index 288f1be..2166ba4 100644 --- a/simulators/README.md +++ b/simulators/README.md @@ -49,7 +49,7 @@ owner · first release · licence · language (checked/unverified) | profile | in one line | track | |---|---|---| -| [`ludii.md`](ludii.md) | the closest relative: ludemes, breadth, speed | A | +| [`ludii.md`](ludii.md) | the closest relative: ludemes, breadth, speed — **syntax formal, semantics is its Java** | A | | [`gdl-ggp.md`](gdl-ggp.md) | the academic ancestor; agent generality over designer support | A | | [`rbg.md`](rbg.md) | regular boardgames — a speed-focused rival description language | A | | [`ai-ai.md`](ai-ai.md) | **the closest relative for what we want to become**: GGP with designer-facing metrics | A, C | @@ -58,6 +58,22 @@ owner · first release · licence · language (checked/unverified) | [`machinations.md`](machinations.md) | economy and feedback loops, diagrammatic | — | | [`play-substrates.md`](play-substrates.md) | Tabletop Simulator, boardgame.io — play without analysis | — | +## The formal question, answered + +**Is there a game-theory mapping to Ludii's language, and is that language +formal enough to derive one from?** + +**Yes to the first, no to the second, and the second does not matter.** +Ludii's universality result grounds it in **finite, non-deterministic, +imperfect-information extensive-form games** — the same object OpenSpiel's +CFR and exploitability consume. Ludii's *grammar* is formal (derived from +its class hierarchy) but its *semantics are its Java*, so there is no +independent calculus to extract. + +**Conclusion: target the extensive-form game directly, not a language +derived from Ludii.** Worked through in +[`../research/CB-RES-0009-extensive-form-is-the-lingua-franca.md`](../research/CB-RES-0009-extensive-form-is-the-lingua-franca.md). + ## What this survey has already changed **Ai Ai and Browne's criteria are the finding.** Track C was written in diff --git a/simulators/ludii.md b/simulators/ludii.md index c2d480a..894a0e3 100644 --- a/simulators/ludii.md +++ b/simulators/ludii.md @@ -12,10 +12,24 @@ reconstruction as a founding motivation. `checked` ## How a game is defined -A ludeme tree with an `equipment` section (pieces, board) and a `rules` -section (setup, play, end conditions). Games are modified by adjusting -ludemes or parameters such as board size. **Each game's description fits -in a QR code.** `checked` +A game is a **quintuple of ludemes** — Name, Players, Mode, Equipment, +Rules. Games are modified by adjusting ludemes or parameters such as board +size. **Each game's description fits in a QR code.** `checked` + +**Syntax formal, semantics not** `checked` — the sharp point, and it +answers "can we derive a formal language from it": **no, there is nothing +semantic to extract.** + +- The grammar is a **class grammar, automatically derived from Ludii's + source**, so keywords and their argument types come from the class + hierarchy. That is more formal than most hand-written grammars. +- But *"Ludii effectively makes its programming language (Java) the game + description language"*: **a ludeme means what its Java class does.** + Compilation produces a forward model (legal moves, apply, copy). + +Contrast **GDL**, which has a logical semantics independent of any +interpreter and pays for it in speed and verbosity. See +[`../research/CB-RES-0009-extensive-form-is-the-lingua-franca.md`](../research/CB-RES-0009-extensive-form-is-the-lingua-franca.md). ## What it can analyse @@ -26,6 +40,17 @@ feature space over games. Depth of design-facing analysis relative to Ai Ai: `open`. +## The game-theoretic mapping + +**Proven, and it is the extensive-form game.** *The Ludii Game +Description Language is Universal* shows the language can represent an +equivalent game for **any finite, non-deterministic, +imperfect-information game**, extending earlier work limited to finite +deterministic fully-observable EFGs. `checked` + +That matters more than it looks: **EFG is also OpenSpiel's object**, so +the same formalism connects description to analysis. + ## What it does not do - It is **a description someone writes**, not a claim about another @@ -63,10 +88,13 @@ ours would have to be that it says something trustworthy about one. ## Open questions - Licence, and whether it permits embedding or only interoperation. -- Can a Ludii description express **simultaneous commit/reveal, hidden - role state, and a binding multi-round state machine** like DARVO? If - not, GROUND is outside its expressiveness and Track A's second game - should be chosen to test that boundary deliberately. +- ~~Can a Ludii description express simultaneous commit/reveal and hidden + role state?~~ **Answered: yes.** Universality covers finite + non-deterministic imperfect-information games, and simultaneity is the + standard EFG information-set encoding. **The live question is whether a + binding multi-round state machine like DARVO stays *readable*** — + universality says expressible, not concise, and concision is Ludii's + actual selling point. - What its analysis output actually contains. ## Sources diff --git a/simulators/openspiel.md b/simulators/openspiel.md index ab3a047..bb02e29 100644 --- a/simulators/openspiel.md +++ b/simulators/openspiel.md @@ -19,6 +19,11 @@ Games are implemented against a C++ (or Python) API. `checked` — this is a *programming* interface, not a description language, which is the axis where Ludii and Ai Ai differ from it. +**But the API is an extensive-form game interface**, and that is the +connection: Ludii's universality proof grounds its language in EFGs, and +OpenSpiel's algorithms consume EFGs. **EFG is the interchange format** +([`../research/CB-RES-0009-extensive-form-is-the-lingua-franca.md`](../research/CB-RES-0009-extensive-form-is-the-lingua-franca.md)). + ## What it can analyse The reason this profile matters for Track B. Implemented algorithms @@ -68,6 +73,13 @@ specific risk `Positioning.md` §4 flags for Track B. ## Open questions - Cost of expressing a GROUND-like game against its API versus our kernel. +- **Whether our engine satisfies perfect recall.** CFR and exploitability + assume it, our per-seat projection has never been checked for it, and + it is checkable from the journal. **This is the first Track B task** — + if it fails, every equilibrium concept is unsound here. +- **Our chance is folded into a seed, not an explicit chance player.** A + clay-borg game is one chance realisation; the panels sample seeds to + approximate the distribution. CFR needs chance nodes. - Whether exploitability is meaningful for a co-operative game with a shared threshold — `open`, and it is the question that decides whether Track B adopts this or only borrows its vocabulary. diff --git a/specs/Positioning.md b/specs/Positioning.md index 428ce6d..71f943f 100644 --- a/specs/Positioning.md +++ b/specs/Positioning.md @@ -153,11 +153,32 @@ everything else, because a Nash equilibrium quoted without its assumptions is exactly the wrong-subject error in mathematical dress ([`Taxonomy.md`](Taxonomy.md) §2.2). -**But the first task is not to build it.** It is to answer one question: -**is exploitability meaningful for a co-operative game with a shared -threshold?** If yes, Track B is mostly integration with -[OpenSpiel](../simulators/openspiel.md). If no, that is a real research -finding and the reason a specialised agent is needed at all. +**But the first task is not to build it**, and the survey narrowed it +twice more ([`../research/CB-RES-0009-extensive-form-is-the-lingua-franca.md`](../research/CB-RES-0009-extensive-form-is-the-lingua-franca.md)). + +**The formal object is the extensive-form game**, proven expressive enough +by Ludii's universality result and consumed directly by OpenSpiel — so +"Ludii → EFG ← OpenSpiel" is the whole mapping, and there is nothing to +invent. + +**And we already have most of an EFG**: the journal is the history, the +payoff is `Outcome`, and **`project(Viewer::Player(seat))` is the +information partition** — built so a player is not shown another's hand, +and unremarked as the machinery imperfect information needs. + +**Three gaps, one checkable today:** + +1. **chance is folded into a seed**, so a clay-borg game is one + realisation rather than a game with chance nodes; +2. **perfect recall is unasserted** — CFR and exploitability assume a + player remembers their own past actions and observations, and nobody + has checked whether our projection sequence does; +3. simultaneity is encoded by commit/reveal but never *stated* as the + standard EFG encoding. + +**Track B's first task is (2)**, because it is small, checkable from the +journal, and if it fails every equilibrium concept we might quote is +unsound here. That is a better opening move than a build. ### Track C — assimilated knowledge about why games work