Formal Specification
Qatari Five Stones Dexterity Catch — Formal Specification
Qatar · dexterity-small · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 3
# Al-Lafha (اللفحة) — AI-optimized specification
## General idea
A five-stone dexterity game structurally unusual in that **its six stages are a gate, not a
scoreboard**. Stages 1-5 award nothing at all; every point in the game comes from the sixth
stage, *Al-Kaff*, at 10 points per stone caught on the back of the hand. Combined with the
rule that a dropped stone ends the turn but **preserves** stage progress, the game becomes
a one-way ratchet: a player grinds through the curriculum once, at whatever cost in turns,
and only then begins scoring.
## Formal model
- **Abstraction taken:** Real hand-eye coordination, toss height, and sweep precision are
collapsed into a per-attempt stochastic success check, one per stage, since the entry
describes each stage's motion qualitatively and gives no success model. The *Al-Kaff*
stage is modelled as 5 independent per-stone catch outcomes rather than one all-or-nothing
check, because the entry scores it per stone ("Each caught stone awards 10 points").
- **Player/agent count:** 2-6 players, each with an independent stage pointer and score.
Players never interact — no rule in the entry lets one player affect another's stones,
turn, or score.
- **Turn model:** Sequential. One player attempts stages until they drop a stone, at which
point the turn passes [gap-fill: the entry does not state the turn order; fixed rotation
in seating order is assumed, being the convention the game's domestic setting implies].
## Formal rules
R1. Setup (entry §1): five pebbles are placed on the mat. One serves as the master stone
(tossed) and the remaining four as grounded stones to be scooped.
R2. Stage pointer: each player holds `stage[p]` ∈ {1..6}, initialised to 1. A turn always
resumes at the player's current `stage[p]`.
R3. Stage attempts (entry §2.1-2.5), each resolving a stochastic success check
[gap-fill: the entry gives no per-stage success rates; a stage-indexed difficulty is
assumed, but no specific numbers are invented here — they are a calibration parameter]:
- Stage 1 `singles()`: toss master, scoop 1 grounded stone, catch master. Four
successive successes required to clear the stage.
- Stage 2 `doubles()`: scoop 2 pairs of 2 while the master is airborne.
- Stage 3 `triples()`: scoop 3 together, then the remaining 1.
- Stage 4 `fours()`: sweep all 4 in one motion while the master is airborne.
- Stage 5 `al_qaws()`: flick stones one by one under an arch formed by the hand.
On clearing a stage, `stage[p]` increments and play continues within the same turn.
R4. Scoring stage (entry §2.6): at `stage[p] = 6` the player submits `al_kaff()` — toss all
5 stones from the palm, catch on the back of the hand, flip and catch in the palm.
Each stone completing the sequence awards **10 points**. Maximum 50 points per attempt.
R5. Foul (entry §3): dropping a stone ends the turn **immediately**, but `stage[p]` is
preserved. Progress is never lost, only the remainder of the turn.
R6. Stage-6 persistence: once `stage[p] = 6` it does not reset; subsequent turns re-attempt
`al_kaff()` for further points [gap-fill: the entry does not say whether clearing stage
6 sends a player back to stage 1. Persistence is the reading forced by arithmetic — the
50-point per-attempt ceiling (R4) means the 100-point target (R7) requires at least two
scoring attempts, and R5's "progress is preserved" states the game's general principle].
R7. Victory (entry §4): the first player whose cumulative score reaches **100 points** wins,
checked the instant it is reached.
## Edge cases
- Tie at the end: not applicable. Turns are strictly sequential (R3) and R7 is evaluated
the moment a score reaches 100, so exactly one player can ever cross the threshold first;
no two players can satisfy the win condition on the same tick.
- A player with no legal move: not applicable — the active player always has the attempt
action for their current stage available, and no stage can be blocked by another player.
- Repetition / cycles: a player may fail the same stage on arbitrarily many consecutive
turns (R5 preserves but does not advance the pointer). Expected and structural; it does
not threaten termination, since each attempt carries a fixed positive success chance.
- Simultaneous claims on one position: not applicable — each player attempts on their own
turn with their own five stones; there is no shared contested object or position.
- Elimination mid-round and turn-order repair: not applicable — no player is ever removed
from the game. Turn order is a fixed rotation over a constant player set (R3), so no
repair mechanism is ever needed.
- Resource exhaustion: not applicable — the five stones are reused every attempt and
nothing in the entry consumes them. Score is strictly accumulating, never spent.
- Termination guarantee: **guaranteed.** Two monotone quantities do the work. First,
`stage[p]` is non-decreasing: R5 preserves it and no rule ever decrements it, and each
stage carries a fixed positive success probability, so every player reaches stage 6 with
probability 1 in finite expected turns. Second, `score[p]` is non-decreasing: no rule
subtracts points. At stage 6, each turn has a fixed positive probability of catching at
least one stone and so gaining at least 10 points, meaning the 100-point threshold (R7)
is crossed with probability 1 in finite expected turns.
## State representation
- Persistent (match) state: `stage[p]` ∈ {1..6} (monotone non-decreasing), `score[p]`
(monotone non-decreasing), `current_player`.
- Per-turn ephemeral state: `stones_scooped_this_stage`, `master_airborne` (bool),
`stones_on_back_of_hand` (during `al_kaff()` only).
- Observable information: fully observable — all stage pointers and scores are public, and
every attempt happens in the open on a shared mat. No hidden information exists.
## Action space
- `singles()` / `doubles()` / `triples()` / `fours()` / `al_qaws()`: the active player;
precondition: `stage[p]` equals the corresponding stage index.
- `al_kaff()`: the active player; precondition: `stage[p] = 6`.
- Turn termination is not an action — it is the forced consequence of a failed check (R5).
## Playability notes
- Single-player-vs-AI: natural, though the interaction is thin. Because players never
affect one another, a human-versus-AI match is two parallel solitaire progressions
compared on a shared clock; the AI needs no opponent model whatsoever.
- Reducing n > 4 to 2 agents: mechanically lossless. Player count changes only how long
the wait between turns is, not the structure of anyone's decision.
- Physical-skill games: this is a pure dexterity game with **no decisions at all** once the
stage pointer is set — the player has exactly one legal action per turn. Every stage is a
skill execution collapsed into a probability, which means the formal model retains the
game's structure while discarding the entirety of what a player actually does.
- What is lost: essentially the whole game. The tactile skill of scooping four stones in one
sweep while a fifth is airborne, the back-of-hand flip that makes *Al-Kaff* the climax,
and the unhurried domestic sociability the entry describes are the reasons the game is
played; none survive abstraction into a success rate.
## Implementation hints
State is tiny — two integers per player — and there is no branching factor to speak of,
since each state admits exactly one legal action. That makes this a poor search problem and
a good **calibration** problem: the only interesting question is what per-stage success
rates produce a game that lasts a plausible number of turns. The representational trap is
scoring stage 6 as a single all-or-nothing check, which changes the score distribution from
a binomial over 5 stones to a Bernoulli over 50 points and materially alters expected game
length. Suggested first milestone: one player, flat per-stage rates, verifying that the
turn count to reach 100 points has the right shape — a long tail from the stage-1-to-5
grind followed by a tight scoring phase.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Qatari Five Stones Dexterity Catch (Qatar). (n.d.). Games of Countries. https://gamesofcountries.com/games/qa-qatar/al-lafha
@misc{gamesofcountries-qa-qatar-al-lafha,
title = {Qatari Five Stones Dexterity Catch (Qatar)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/qa-qatar/al-lafha}
}