CB-RES-0009: extensive form is the lingua franca

Two questions from the maintainer — is there a game-theory mapping to
Ludii's language, and is that language formal enough to derive one from.
Yes, no, and the no does not matter.

The mapping is proven, not to be invented: "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
extensive-form games. EFG is also OpenSpiel's object, so the same
formalism connects description to analysis: Ludii -> EFG <- OpenSpiel.

Ludii's syntax is formal and unusually so — a class grammar derived
automatically from its source. Its semantics are its Java: a ludeme means
what its class does, and Ludii effectively makes Java the game description
language. So there is no independent calculus to extract. The formality
lives in the universality RESULT, not in a definition of meaning. GDL has
the semantics and pays for it in speed — six times on Gomoku, twenty on
Amazons and Hex, over two hundred on Chess.

Conclusion: do not derive a language from Ludii; target the EFG directly.

And we are closer than the tracks assumed. The journal is the history,
Outcome is the payoff, legal_commands gives the actions — and
project(Viewer::Player(seat)) IS the information partition, built so a
player is not shown another's hand and unremarked as exactly the machinery
imperfect information needs.

Three gaps: chance is folded into a seed so a game is one realisation
rather than a game with chance nodes; perfect recall is unasserted, which
CFR and exploitability both assume; and commit/reveal is the standard EFG
encoding of simultaneity but is never stated as such. Perfect recall is
checkable from the journal today and is now Track B's first task — if it
fails, every equilibrium concept we might quote is unsound here.

Also re-vendored the catalog twice: ground-game added H2 — scoped problem
stress, applying End Stress by personal/bond/global scope instead of flat
to everyone, which is a direct response to our reading that H1's tax
scales with the Problems while its intended effect does not.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

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.

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

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

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

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

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.

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