Formal Specification
Liberian Palm-Nut Balancing and Dexterity Game — Formal Specification
Liberia · dexterity-small · Confidence: low
← Back to game pageImplementation 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 JSONCite 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}
}