Skip to main content
Formal Specification

Ring Game — Formal Specification

Montenegro · guessing-hidden · Confidence: high

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: directGap-fills: 2
# Igra prstena — AI-optimized specification ## General idea An asymmetric imperfect-information deduction game played with a fixed array of covers (socks or caps) and a hidden ring. One team secretly places the ring under one cover, and the opposing seeker systematically lifts covers to eliminate empty ones, seeking to leave the ring under the final remaining cover. The game features subtle risk-reward trade-offs between cautious cover-by-cover elimination and early direct calls. ## Formal model - **Abstraction taken:** Direct representation of the physical table layout as a discrete list of `K = 10` cover slots `[0..9]`. The physical hand sleight-of-hand is abstracted to a private index selection `hidden_index in [0..9]`. - **Player/agent count:** 2 teams (Team A and Team B), each with an assigned captain per round. - **Turn model:** Two-phase rounds: Phase 1 (Hiding: secret choice), Phase 2 (Seeking: sequential cover lifts). ## Formal rules R1. Setup: State includes an array of `K = 10` covers, all initially active (`state = UNTOUCHED`). Scores for Team A and Team B initialize to 0. Target score is set to `TARGET = 101`. R2. Hiding phase: The active hiding team secretly submits `place_ring(slot_idx)` where `slot_idx in [0..K-1]`. The value of `slot_idx` is hidden from the seeking team. R3. Seeking phase: The seeking captain repeatedly executes `lift_cover(slot_idx)` on any cover currently in state `UNTOUCHED`. R4. Lift resolution: - If `slot_idx != hidden_index`: Cover status becomes `CLEARED_EMPTY`. If the number of remaining `UNTOUCHED` covers is now 1, the round ends in a **Perfect Seeker Win**: the seeking team scores `K` points (`10` points), and becomes the hiding team in the next round. - If `slot_idx == hidden_index` while `count(UNTOUCHED) > 1`: The round ends immediately in an **Early Seeker Fault**. The hiding team scores points equal to the number of remaining `UNTOUCHED` covers (including the ring cover), and remains the hiding team in the next round. R5. [gap-fill] Direct guess rule: A seeker may optionally execute `call_ring_direct(slot_idx)`. If `slot_idx == hidden_index`, seeker immediately scores `K` points and takes the hide; if incorrect, hiding team scores `K` points and keeps the hide. R6. Match termination: The match ends immediately at the conclusion of any round where a team's accumulated score `>= TARGET`. The team with the higher score wins. R7. [gap-fill] If both teams reach `>= TARGET` in the same round (possible under alternative scoring), the team with the higher total wins; if exactly tied, another round is played with alternating roles until the tie is broken. ## Edge cases - Tie at the end condition: Resolved via R7 (sudden-death round). - A player with no legal move: Not applicable; hiding team always has `K` slots available, seeker always has remaining `UNTOUCHED` slots available. - Repetition / cycles: Score strictly increases each round by at least 1 point (hiding team gets `>= 1` point on a miss, seeker gets `K` points on a win); thus reaching `TARGET` is mathematically guaranteed in a finite number of rounds. - Simultaneous claims on the same resource or position: Not applicable; turns alternate strictly between hiding and seeking phases. - Player elimination mid-round; turn order repair: Team-based game; if a player drops out, remaining team members assume captaincy without state interruption. - Resource exhaustion: Cover array resets fully at the start of each new round. - Termination guarantee: Because each round generates a strictly positive integer score addition (`>= 1`) to one team, the total score monotonically increases and must reach `TARGET = 101` in at most `2 * TARGET` rounds. ## State representation - Persistent state: `score_team_A: int`, `score_team_B: int`, `hiding_team: TeamID`, `round_number: int`. - Per-round ephemeral state: `hidden_index: int (0..9, private to hiding team)`, `covers: array[10] of {UNTOUCHED, CLEARED_EMPTY, REVEALED_RING}`. - Observable information: Hiding team observes `hidden_index` and all public actions; Seeking team observes only public actions and cover statuses (`UNTOUCHED` vs `CLEARED_EMPTY`). ## Action space - `place_ring(slot_idx: int)`: Precondition: Hiding phase active; `0 <= slot_idx < K`. - `lift_cover(slot_idx: int)`: Precondition: Seeking phase active; `covers[slot_idx] == UNTOUCHED`. - `call_ring_direct(slot_idx: int)`: Precondition: Seeking phase active; `covers[slot_idx] == UNTOUCHED`. ## Playability notes - Single-player-vs-AI: Engine-ready; AI hider uses mixed-strategy Nash equilibrium over slot placement, AI seeker tracks Bayesian probabilities based on historical bluffing patterns. - Group games (n>4): Reduces naturally to 2 agents (1 captain per team) without altering formal game dynamics. - Physical-skill games: Not applicable (pure deduction / bluffing / hidden-information game). - What is lost: Physical micro-expressions, trembling hands, and verbal banter are abstracted into clean Bayesian decision-making. ## Implementation hints Ideal candidate for imperfect-information tree search (CFR or MCTS for POMDPs). State size per round is minuscule (10 slots, 3 states each). Milestone 1: Implement two-phase deterministic state engine with random-hider baseline. Milestone 2: Implement Bayesian belief updater for seeker agent.

Download as JSON

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

Download JSON
Cite this page

Ring Game (Montenegro). (n.d.). Games of Countries. https://gamesofcountries.com/games/me-montenegro/igra-prstena

@misc{gamesofcountries-me-montenegro-igra-prstena,
  title = {Ring Game (Montenegro)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/me-montenegro/igra-prstena}
}