Skip to main content
Formal Specification

Violet chain-breaking singing game — Formal Specification

Azerbaijan · singing-circle · Confidence: low

← Back to game page

Implementation Suitability

Suitability: adaptation-requiredFidelity: probabilistic-proxyGap-fills: 2
# Bənövşə — AI-optimized specification ## General idea A chain-breaking sprint game whose structural core is a zero-sum player-transfer economy: total player count across both teams never changes, and every single round moves exactly one player from one team to the other — the runner joins the defending team on failure, or takes one defender back to their own team on success. This makes team-size difference a bounded random walk with absorbing endpoints at "one team has everyone." ## Formal model - **Abstraction taken:** Real chest-and-arm breakthrough force and grip strength are abstracted into a single stochastic breakthrough-success check per attempt, since the entry describes the physical clash qualitatively without a numeric force model. The call-and-response song itself carries no separate gameplay branching beyond determining role assignment for the round. - **Player/agent count:** 2 teams; `team_size[A] + team_size[B] = T`, constant throughout the game (T set at setup and never changes, since players only move between teams, never leave play). - **Turn model:** Sequential rounds. Each round: role assignment (Sender/Target), a single named runner, a single breakthrough attempt, resolution. ## Formal rules R1. Setup: two teams line up 15-20 m apart, each linking hands into a chain (entry §1.1-1.2). `team_size[A]` and `team_size[B]` are set to the starting rosters; `T = team_size[A] + team_size[B]`. R2. Role assignment per round: exactly one team is `Sender` and the other is `Target` for the round; the Sender role alternates between teams each round (entry §5.1, "teams alternate singing and sending runners"), starting with a fixed team at setup. R3. Naming: the `Target` team selects (via the call-and-response song, entry §2.1) one player from the `Sender` team's current roster to be the `runner` for this round [gap-fill: the entry's transliterated dialogue — "from us to you, who falls?" sung by one side, answered by the other naming a specific player — is read here as: the singing team that poses the "who falls from us to you" question is the `Sender` (the "us" whose player falls), and the team that answers by naming the specific player is the `Target`, who is thereby choosing which of the Sender's own players must attempt to break the Target's chain; this reading is the only one internally consistent with the entry's own summary that a team "challenges a specific member of the opposing team by name" and that player then attacks the *challenging* team's chain]. R4. Sprint and clash (entry §3.1-3.3): the `runner` submits `sprint_and_break(link_position)`, targeting a specific link (pair of adjacent hands) in the `Target` team's chain. This resolves a stochastic breakthrough-success check. R5. Breakthrough success (entry §4.1): the runner breaks the chosen link, selects one of the two defenders who held that link, and that defender transfers to the `Sender` team's roster (`team_size[Sender] += 1`, `team_size[Target] -= 1`). The runner themselves remains on the Sender team (they were never at risk of transfer on a success). R6. Breakthrough failure (entry §4.2): the runner is captured and transfers to the `Target` team's roster (`team_size[Target] += 1`, `team_size[Sender] -= 1`) — note the runner was drawn from the Sender team (R3), so this is the runner themselves changing sides. R7. Win condition (entry §5.2): the game ends the instant either `team_size[A] = 0` or `team_size[B] = 0` (one team has absorbed every player), or when an external time limit expires and one team holds a "decisive majority" [gap-fill: the entry does not define "decisive majority" numerically; treated as an external session parameter, not an invented threshold]. ## Edge cases - Tie at the end: not applicable via the full-absorption win condition (R7's first clause is a strict 0 for one side); if the game instead ends via the external time-expiry clause, the entry gives no tiebreak for an exactly even split, which is a genuine silence. - A player with no legal move: not applicable — every round has a well-defined `Sender`, `Target`, and `runner` as long as both teams have at least 1 player; the game itself ends (R7) before either team could reach a state with no players to name. - Repetition / cycles: possible in the sense that team-size difference can oscillate for many rounds without reaching an absorbing boundary, but this does not prevent eventual termination (see Termination guarantee below) — it is a normal feature of a bounded random walk, not a stuck state. - Simultaneous claims on one position: not applicable — R5's "choose one of the two defenders" is the runner's unilateral choice with no contest between the two defenders themselves. - Elimination mid-round and turn-order repair: not applicable — no player is ever removed from the game; every transfer (R5, R6) relabels a player's team, it never removes them from play. - Resource exhaustion: not applicable — `T` is fixed and conserved every round; there is no consumable resource beyond the two teams' rosters, which only exchange members. - Termination guarantee: `team_size[A]` performs a bounded random walk on the integers `[0, T]` (each round it moves by exactly +1 or -1 with fixed non-zero probabilities set by the breakthrough-success rate, R5/R6), with `0` and `T` as absorbing states (R7). A bounded random walk with non-zero step probabilities in both directions and absorbing boundaries reaches one of its absorbing states with probability 1 in finite expected time — a standard gambler's-ruin argument. This holds independent of the external time-expiry clause, which can only end the game earlier. ## State representation - Persistent (game) state: `team_size[A]`, `team_size[B]`, `sender_this_round` (alternates, R2). - Per-round ephemeral state: `runner_id`, `target_link_position`. - Observable information: fully observable — team rosters, sizes, and round outcomes are public; no hidden information. ## Action space - `sprint_and_break(link_position)`: the named `runner` only; precondition: it is their round as the designated runner (R3). ## Playability notes - Single-player-vs-AI: workable as a human controlling one team's overall strategy (there is little per-player decision-making beyond the Target team's naming choice, R3) against an AI-controlled opposing team. - Reducing team size: mechanically consistent at any team size ≥ 1 per side, though the random-walk termination argument (above) becomes faster to resolve as `T` shrinks. - Physical-skill games: real breakthrough force, grip strength, and defensive bracing are the entire physical contest and are collapsed into the single stochastic breakthrough check (R4); no genuine biomechanics are modeled. - What is lost: the actual poetic call-and-response verses and melodic singing, the specific drama of a named player being singled out in front of both teams, and the festival framing (Novruz, Çillə) that gave the game its seasonal significance. ## Implementation hints State is minimal (two integers summing to a constant, plus a small per-round record); the real design difficulty is calibrating the breakthrough-success probability, which the source does not quantify, and which functionally determines how the random walk is biased. First milestone: implement the round loop (R2-R6) with a flat 50/50 breakthrough probability to validate the zero-sum transfer accounting and the full-absorption win condition (R7), then bias the probability by chain composition or fatigue if desired.

Download as JSON

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

Download JSON
Cite this page

Violet chain-breaking singing game (Azerbaijan). (n.d.). Games of Countries. https://gamesofcountries.com/games/az-azerbaijan/benovshe

@misc{gamesofcountries-az-azerbaijan-benovshe,
  title = {Violet chain-breaking singing game (Azerbaijan)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/az-azerbaijan/benovshe}
}