Skip to main content
Formal Specification

Liberian Palm-Nut Balancing and Dexterity Game — Formal Specification

Liberia · dexterity-small · Confidence: low

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 3
# Kpana — AI-optimized specification > **Reconstructed source.** The entry carries a provenance warning: its rules were written > from general knowledge, not read from the two ethnographies it cites. Gay & Cole (1967) and > Schwab (1947) are real works, but the entry does not evidence that either describes this > game. ## General idea A palm-kernel jacks game built as a **stage ladder with no recovery**: a player advances through fixed dexterity stages, and a single dropped kernel ends the turn immediately and passes play on. The interesting structural property is that the game contains **no decisions at all** — every stage prescribes exactly what to attempt, so a player's entire influence on the outcome is physical execution. For an engine this makes it a pure skill-check ladder, and it is worth being honest that formalizing it produces a simulation rather than a game. ## Formal model - **Abstraction taken:** Tossing, flipping the hand, catching on the back of the hand, and scooping kernels off the ground are collapsed into per-attempt success probabilities. The entry specifies the stages exactly but gives no timing, no heights, and no success model. - **Player/agent count:** 2-6, acting in rotation (entry §1). - **Turn model:** Strictly sequential turns; within a turn, a sequence of independent attempts continuing until the first failure. ## Formal rules R1. Setup (entry §1): players sit in a circle on packed dirt or a woven mat. Materials are **10 small palm kernels** and **1 master tossing stone**. R2. Stage 1 — back-hand catch (entry §2): toss all 10 kernels, flip the hand over and catch as many as possible on the **back** of the hand, then toss those again and catch them in the palm [gap-fill: the entry gives no threshold for passing this stage — "as many as possible" is not a success condition. Requiring at least one kernel to survive both catches is the minimal reading]. R3. Stage 2 — progressive scooping (entry §3): toss the master kernel, scoop **1** kernel from the ground, and catch the master kernel before it lands. Repeat for **2**, then **3**, then **4** kernels. R4. Failure (entry §4): dropping a kernel **terminates the turn immediately** and passes play to the next player [gap-fill: the entry does not say whether a player resumes at the stage they failed on or restarts from Stage 1. Resuming at the failed stage is assumed, since the entry frames the stages as cumulative progress]. R5. Victory (entry §5): the first player to complete **all 5 stages** wins. R6. Stage count discrepancy: R5 names **five** stages, but the entry describes only two — Stage 1 and Stage 2's four scooping steps [gap-fill: the most coherent reconciliation is that the four scooping steps of R3 plus the back-hand catch of R2 constitute the five stages. This is a reading of the entry's own arithmetic, not an addition to it, but the entry does not state it]. ## Edge cases - Tie at the end: not applicable — R5 resolves on a single player completing the ladder during their own turn, and turns are strictly sequential (R4), so exactly one player can be first. - A player with no legal move: not applicable. The active player always has the attempt their current stage prescribes; waiting players have no actions by construction, which is a property of turn order rather than a stuck state. - Repetition / cycles: turns may rotate indefinitely with every player failing early. This is expected — it is the game's normal texture — and it is the reason termination rests on a probabilistic argument rather than a bound. - Simultaneous claims on one position: not applicable — one player acts at a time, and the kernels on the ground are handled only by the active player. - Elimination mid-round and turn-order repair: no player is ever eliminated. R4 passes the turn but keeps the player in the rotation, so the turn order is a fixed cycle needing no repair. - Resource exhaustion: not applicable — the 10 kernels and master stone are recovered between turns and nothing is consumed. Kernels scooped in R3 return to the ground for the next player. - Termination guarantee: **not guaranteed as stated, though it holds under any reasonable skill model.** No clock, no round limit, and no score bound the game; the only end is R5. Each player's turn terminates almost surely, since every attempt carries a fixed positive probability of a drop (R4). But whether *anyone* ever completes all five stages depends on a per-attempt success probability the entry never supplies — and if any stage's success probability were zero, the game would never end. Since the entry gives no model at all, `termination_guaranteed: false` records that honestly. Under any model with strictly positive per-stage success, completion occurs with probability 1 in finite expected turns. ## State representation - Persistent (game) state: `stage_reached[p]` for each player (monotone non-decreasing under R4's assumed reading), `current_player`. - Per-turn ephemeral state: `kernels_in_hand`, `kernels_on_ground`, `kernels_on_back_of_hand`, `master_in_flight`, `attempt_index` within the current stage. - Observable information: fully observable — every toss and drop happens in the open circle and all players' progress is public. ## Action space - `toss_all()`: the active player at Stage 1 (R2). - `flip_and_catch()`: the active player; resolves the back-of-hand catch (R2). - `toss_master()`: the active player at Stage 2 (R3). - `scoop(n)`: the active player; `n` ∈ {1, 2, 3, 4} fixed by the current step of R3. - `catch_master()`: the active player; the timing-critical half of every Stage 2 step (R3). - Note that none of these is a *choice* — the stage determines which action is legal, so the action space has exactly one element at every point. ## Playability notes - Single-player-vs-AI: poor, and the reason is structural rather than incidental. With no decisions (see the action space), an AI opponent has nothing to decide and the contest reduces to comparing two random number streams. A solo skill-ladder framing, where the player's own input drives the success check, is the only version worth building. - Reducing n > 4 to 2 agents: lossless mechanically — players never interact, so the game is a set of parallel solitaires that happen to share a rotation. What shrinks is only the social scene, which is most of what the game actually is. - Physical-skill games: fine motor precision, catch timing, and the back-of-hand flip *are* the game, and every one collapses into a probability draw. Nothing else remains. - What is lost: the tactile particulars — polished palm kernels or smooth river stones, the packed-dirt circle, the harvest-season setting the entry describes — and, per the entry's variant note, the Mano singing cadences that govern toss timing. A cadence that sets rhythm is a mechanic, and no probability captures it. ## Implementation hints Make the per-stage success probability an explicit, tunable parameter and label it clearly as an addition — the entry supplies none, and the choice of curve determines both game length and whether the game terminates at all (see the termination note). The representational trap is R4: a turn ends at the **first** drop, so an implementation that lets a player retry within a turn removes the entire tension of the ladder and makes completion certain. Build R2's threshold as configuration too, since the entry's "as many as possible" is not a pass condition. Suggested first milestone: the Stage 2 scooping ladder with a flat success rate, verifying that turn lengths shorten as `n` rises and that the rotation advances on every drop.

Download as JSON

Download the full game corpus entry for this game as structured JSON.

Download JSON
Cite this page

Liberian Palm-Nut Balancing and Dexterity Game (Liberia). (n.d.). Games of Countries. https://gamesofcountries.com/games/lr-liberia/kpana-liberia

@misc{gamesofcountries-lr-liberia-kpana-liberia,
  title = {Liberian Palm-Nut Balancing and Dexterity Game (Liberia)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/lr-liberia/kpana-liberia}
}