Formal Specification
Bambara Traditional Singing Circle and Tag Game — Formal Specification
Mali · singing-circle · Confidence: low
← Back to game pageImplementation Suitability
Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 3
# Tulon Kè — AI-optimized specification
> **Reconstructed source.** The entry carries a provenance warning: its rules were written from
> general knowledge, not read from the two works it cites. Dieterlen (1951) and Imperato (1986)
> are real books, but the entry does not evidence that either describes this game.
## General idea
A circle-and-chase game built on a **deliberately delayed detection**: the runner's advantage
comes entirely from how long the target takes to notice the cloth behind them, and the singing
that fills the circle is not decoration but the mechanism that masks the drop. The formal
structure is a one-against-many partial-observability problem where the *many* are almost entirely
passive — a seated player's only decision is how much attention to spend, and the entry gives no
way to spend less or more. What it does give is an asymmetric failure: a runner who is tagged
**must run again**, so failure is punished with repetition rather than role loss.
## Formal model
- **Abstraction taken:** Peripheral vision, reaction time, and the footrace around the circle are
collapsed into stochastic checks — a per-tick detection probability for the target and a race
outcome once the chase begins. The entry describes the sequence exactly and supplies no timings,
no circle size, and no success model.
- **Player/agent count:** 6-20 children (entry §Players); exactly 1 active runner at a time, the
rest seated.
- **Turn model:** Continuous ticks during the runner's circuit; the chase is a synchronous race.
## Formal rules
R1. Setup (entry §1): players sit in a circle facing **inward**, clapping and singing Bambara
call-and-response songs. Facing inward is a mechanical constraint, not flavour — it is why the
perimeter is unobserved.
R2. Circuit (entry §2): the active runner walks the **outside** perimeter holding the cloth knot
(*Daba*) **secretly**.
R3. Drop (entry §3): the runner drops the cloth behind one seated player and **begins sprinting**
around the circle.
R4. Detection and chase (entry §4): the seated player must **notice** the cloth, pick it up, and
chase the runner around the perimeter. Detection resolves as a per-tick stochastic check
[gap-fill: the entry gives no detection mechanism, no time limit on noticing, and no
consequence for a target who never notices at all — arguably the most common real outcome, and
entirely unaddressed].
R5. Safe circuit (entry §5): if the runner completes the circle and sits in the **vacant spot**,
they are safe and the **chaser becomes the new runner**.
R6. Tag (entry §6): if tagged before sitting, the runner **must run again** — retaining the role
rather than losing it. The target returns to their seat
[gap-fill: the entry does not say whether the tagged runner restarts with the same cloth from
the same position, or resumes the perimeter walk from the start].
R7. Match structure: **none.** The entry defines no score, no target, no number of rounds, and no
end condition [gap-fill: how a session concludes is a social decision the entry does not
encode].
## Edge cases
- Tie at the end: not applicable, and not merely unaddressed — R7 defines no end and no score, so
there is nothing that could tie. The game has no result, by design rather than omission.
- A player with no legal move: not applicable. The runner always has `walk`, `drop`, or `sprint`;
a seated player always has `sit` and, once the cloth is behind them and detected, `chase`.
- Repetition / cycles: **central to the game rather than incidental.** R6 explicitly returns a
tagged runner to the same role, so an unsuccessful runner can repeat indefinitely, and R5's role
transfer can circulate among the same few players forever. This is the intended texture and is
the direct cause of the termination failure below.
- Simultaneous claims on one position: **the game's one real contention, and R5 depends on it.**
The vacant spot is a single position that both the runner and the returning chaser are racing
for, and it admits exactly one occupant. The entry resolves this only implicitly, by whoever
arrives first; it does not address a genuine dead heat, and none is invented.
- Elimination mid-round and turn-order repair: no player is ever eliminated. The seating circle is
a fixed structure whose only change is which single seat is vacant, and R5's role handover
swaps two players' states without altering the circle — so there is no order to repair.
- Resource exhaustion: not applicable — the single cloth knot is the only object and is passed
rather than consumed. Children's stamina is the real limit on how long a session runs, and it is
precisely what R7 fails to encode.
- Termination guarantee: **not guaranteed, and correctly so.** Each individual chase resolves with
probability 1 — the perimeter is bounded and the race has a fixed positive chance of each
outcome. But the **session** has no end at all (R7): no score, no round count, no winner. Under
R6, a runner can even fail indefinitely. This is continuous social play rather than a contest,
and `termination_guaranteed: false` records that honestly instead of inventing a stopping rule
the tradition does not have.
## State representation
- Persistent (session) state: `runner_id`, `seat_occupancy` (exactly one vacant seat while a runner
is circulating), `cloth_position` ∈ {held_by_runner, behind_seat_k, held_by_chaser}.
- Per-circuit ephemeral state: `runner_perimeter_angle`, `chaser_perimeter_angle`,
`target_seat`, `detected` (bool), `ticks_since_drop`.
- Observable information: **partially observable, and the asymmetry is the entire game.** Seated
players face inward (R1) and cannot observe the perimeter or the cloth behind them; the runner
observes everything. An engine that gives seated agents full visibility has deleted the game
rather than simplified it.
## Action space
- `walk(step)`: the runner; the perimeter circuit before dropping (R2).
- `drop(seat)`: the runner; precondition: holding the cloth, adjacent to the chosen seat (R3).
This is the only genuine strategic choice in the game — which target, and how far around.
- `sprint()`: the runner; the dash for the vacant seat (R3, R5).
- `chase()`: the target; precondition: `detected` (R4).
- `sit()`: the runner at the vacant seat, or the chaser returning; resolves R5.
## Playability notes
- Single-player-vs-AI: workable and genuinely interesting on the runner's side, where `drop(seat)`
is a real decision — dropping behind an attentive player near the end of the circuit is a
different risk from dropping behind a distracted one early. On the seated side there is
essentially nothing to decide, since the entry gives a target no way to allocate attention.
- Reducing n > 4 to 2 agents: does not survive. The circle is the game's structure, and with two
players there is no perimeter to circulate, no vacant seat to race for, and no choice of target.
- Physical-skill games: peripheral awareness, reaction time, and sprint speed are the whole
contest and collapse into two probability checks (R4, R5). Circle diameter — which determines
how much of a head start the drop confers — is never stated and is the parameter that most
affects balance.
- What is lost: the singing, which is the game's actual mechanism and not its soundtrack. The
call-and-response fills the auditory channel and masks the drop, and the entry names it first
among the game's features; a detection probability captures none of it. Also lost is the Dogon
cliff-village variant the entry records, where a polished river pebble is passed hand-to-hand
instead — a materially different game with a different information structure.
## Implementation hints
Make the detection check (R4) depend on the drop's distance behind the target and on elapsed ticks,
not on a flat per-round probability: the runner's choice in `drop(seat)` is only meaningful if
where and when they drop changes the odds, and a constant detection rate makes the sole strategic
action irrelevant. Model the singing explicitly as a detection penalty if any fidelity to the
entry's own emphasis is wanted, and label that as an addition. The representational trap is R6 —
a tagged runner **keeps** the role, which is the opposite of the more familiar circle games where
tagging transfers it, and getting this backwards inverts the incentive structure entirely. Do not
add a match end; R7's silence is a finding about the game, not a gap to fill in code, and any
session length imposed must be labelled as the implementation's own. Suggested first milestone:
the circle with one runner, a distance-and-time-dependent detection check, and the race for the
vacant seat, verifying that R6 returns the same runner and R5 swaps roles.
Download as JSON
Download the full game corpus entry for this game as structured JSON.
Download JSONCite this page
Bambara Traditional Singing Circle and Tag Game (Mali). (n.d.). Games of Countries. https://gamesofcountries.com/games/ml-mali/tulonke-bambara
@misc{gamesofcountries-ml-mali-tulonke-bambara,
title = {Bambara Traditional Singing Circle and Tag Game (Mali)},
year = {n.d.},
publisher = {Games of Countries},
url = {https://gamesofcountries.com/games/ml-mali/tulonke-bambara}
}