Skip to main content
Formal Specification

Indigenous Rattan Topological Disentanglement Puzzle — Formal Specification

Malaysia · dexterity-small · Confidence: low

← Back to game page

Implementation Suitability

Suitability: engine-readyFidelity: probabilistic-proxyGap-fills: 2
# Kercang — AI-optimized specification ## General idea A discrete topological state-space disentanglement puzzle. An agent navigates a flexible looped cord through a directed graph of rigid rattan rings, cross-bars, and toggles, applying valid topological loop transitions (passes, bight inversions, and loops over nodes) to transform the system from a locked initial state to an unlinked final state with minimum transition steps. ## Formal model - **Abstraction taken:** Direct topological abstraction. The physical 3D rattan frame is modeled as a rigid topological knot graph G=(V,E) where vertices represent rattan rings/holes and toggle bars. The flexible cord is modeled as a cyclic word / sequence of oriented crossings W∈Σ∗ over the graph generators. - **Player/agent count:** 1 agent (single-player puzzle solver) or N agents competing in a parallel time-minimization race. - **Turn model:** Discrete sequential action steps. Each step, the agent applies one valid topological move to the cord. ## Formal rules R1. Topological state representation: - Frame topology: Graph G=(V,E) with |V|=9 loop nodes (standard *Kercang Kahwin* 9-ring configuration). - Cord configuration: State vector S=(v1,v2,…,vm) representing the sequence of directed passages through nodes vk∈V. - Locked initial state: Sinit=S0 (fully entangled cord traversing all 9 nodes in specific parity). - Unlocked goal state: Sgoal=∅ (cord completely detached from G). R2. Legal topological actions: - At state S, legal moves correspond to valid Reidemeister-type loop operations: - `pass_loop_through(node_id, direction)`: Advances a bight of the cord through ring `node_id`. - `slip_over_post(node_id, post_id)`: Slips an expanded bight over an adjacent wooden toggle/post. - `invert_bight(node_id)`: Reverses the local loop orientation through ring `node_id`. - `retract_loop(node_id)`: Pulls a liberated loop backward through ring `node_id`. R3. Physical invariants: - No cutting, stretching beyond loop radius, or altering the rigid graph G. - A move is valid if and only if the cord length constraint ∑arc_length≤Lmax is satisfied at all times during the transition. R4. Transition resolution: - Applying a valid action a∈𝒜(S) deterministically yields next state S′=f(S,a). - Applying an invalid action returns state unchanged with an invalid-move flag. R5. Win condition: - The puzzle is solved when the state reaches S=Sgoal. - In timed racing mode, the agent reaching Sgoal in the fewest steps (or lowest elapsed simulated time) wins the match. R6. [gap-fill] Step limit & loop-breaking: If an agent exceeds Kmax=200 action steps without reaching Sgoal, the attempt is terminated with a status of `UNSOLVED`. R7. [gap-fill] Reverse challenge mode: Upon reaching Sgoal, an optional reverse task requires transforming Sgoal→Sinit to test bidirectionality. ## Edge cases - Tie at the end condition: In parallel time-trials, tie broken by fewer total topological operations; if equal, a draw is recorded. - A player with no legal move: Not applicable; topological graph always allows at least the inverse of the preceding move (backtracking). - Repetition / cycles: Resolved by standard graph cycle detection (visited state set) and the hard Kmax=200 step limit. - Simultaneous claims on the same resource or position: In multi-agent races, each agent operates on an independent identical copy of the puzzle graph. - Player elimination mid-round; turn order repair: Single-player or decoupled parallel execution; agent timeout does not affect peers. - Resource exhaustion (pieces, tokens, space, time): Cord length Lmax bounds loop expansion; step limit Kmax bounds execution time. - Termination guarantee: State space is finite (|V|≤9, cyclic word length bounded by Lmax); search is guaranteed to terminate either at Sgoal or step limit Kmax. ## State representation - Persistent state: Frame graph G=(V,E), node capacities, maximum cord length Lmax, `step_limit` (200). - Ephemeral state: Current cord sequence S∈V∗, step counter k, history of visited states `set(S)`. - Observable information: Perfect information; the full physical configuration and cord path are visible at all times. ## Action space - `pass_through(node_id, dir)` - `slip_over(node_id, post_id)` - `invert(node_id)` - `retract(node_id)` - `reset_to_start()` ## Playability notes - Single-player-vs-AI: Natural single-player automated reasoning benchmark; solvable via A* search, BFS, or reinforcement learning. - Group games (n>4): Decoupled parallel race where multiple AI agents or human players compete to find the optimal shortest-path solution. - Physical-skill games: Physical rattan flexing is formalized into discrete combinatorial knot-state transitions. - What is lost in the adaptation: The tactile feedback of seasoned wild rattan friction and cord tension is abstracted into discrete graph moves. ## Implementation hints Model as a formal planning domain (PDDL) or an explicit state-space search graph. State can be hashed as a canonical string of signed node visits. Branching factor is small (b≈3..6). First milestone: implement *Kercang Selapis* (3-node sub-graph, minimal solution length ~7 moves) before tackling full 9-node *Kercang Kahwin* (~2^k state explosion).

Download as JSON

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

Download JSON
Cite this page

Indigenous Rattan Topological Disentanglement Puzzle (Malaysia). (n.d.). Games of Countries. https://gamesofcountries.com/games/my-malaysia/kercang

@misc{gamesofcountries-my-malaysia-kercang,
  title = {Indigenous Rattan Topological Disentanglement Puzzle (Malaysia)},
  year = {n.d.},
  publisher = {Games of Countries},
  url = {https://gamesofcountries.com/games/my-malaysia/kercang}
}