SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2602.00190 · 2026

From Gameplay Traces to Game Mechanics: Causal Induction with Large Language Models

Bodo Rosenhahn, Alexander Dockhorn, Mohit Jiwatode

arXiv · PDF · Open in the Atlas

Code that ran

13 of 15 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 1 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 12 failures of our instrument; 2 no recorded run), measured 2026-11-22; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2602.00190.json · badge: /api/ran/2602.00190.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
jiwatode-mohit/SCM_4_GVGAI canonical (classifier label)
classifier basis: census
13 ran · 2 no recorded run
FunctionStatusWhere it lives
build_prompt_standard Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/utils.py
code served (permissive licence) · get_code("cde900d8d85bd592")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
from typing import Dict, Optional

# Define the descriptions dict that is used in the function
descriptions = {
    'racebet': "The objective of this game is guessing which camel is going to win the race. Betting is performed by placing the player in one of the corresponding betting spots. No points are given in this game. You either bet for the one that wins (and the player wins) or you don't (and the player loses).",
    'digdug': 'The player must collect all gems and gold coins in the cave, digging its way through it, to win the game. There are also enemies in the level that kill the player on collision with them. Also, the player can shoot boulders by pressing USE two consecutive time steps, which kill enemies.',
    'brainman': 'The player must push keys into doors to open them, to reach the exit to win the game. Many gems around are available for collection, which give score to the player. Keys are pushed by colliding with them, and they are propelled in a straight line until finding a sprite to collide against, when they stop. If they hit a door, both the door and the key are destroyed.',
    'defender': 'The objective of this game is to avoid that the enemies destroy your city. The enemies are spawned at the right of the screen and cross it while bombing the city. The player must eliminate these enemies as soon as possible so the city is not destroyed, otherwise the player loses. The player\'s ammunition is supplied from the top of the screen and must be collected periodically to avoid running out of ammo.',
    'lasers2': 'The objective of this game is to reach the exit, which is typically blocked by a mud sprite. The mud can be destroyed by directing a laser to it. There are several laser cannons whose orientation can be changed by the player shooting at them. Apart from this, there are several crystal blocks, which can also be rotated, that deflect the lasers in a certain direction. Lasers kill the player when in contact.',
    'boulderchase': 'In this game, the player must dig inside a cave to collect at least 9 gems and reach the exit. As the player digs, boulders that are left without a ground fall and can kill the player upon collision. Enemies also move around the cave, being able to dig as well. When digging, they drop gems that can also be collected by the player. Enemies are also killed by boulders and kill the player upon contact.',
    'portals': 'The player controls an avatar that needs to find the exit of a maze. The maze is full of entry and exit portals, and every time the player goes through an entry portal they will be teleported to an exit portal at random. The maze is also full of enemies and missiles that kill the player on contact.',
    'iceandfire': 'The objective of this game is to find the exit of the maze. The maze has multiple traps, two different types of surfaces (ice and fire), and two types of boots (for ice and fire) that can be collected. The special surfaces kill the player on contact, unless the appropriate boots are picked up beforehand. There are several coins scattered around the level that give the player some score.',
    'cakybaky': 'The objective of the game is to bake a cake. There are several ingredients that must be collected in order, to follow the recipe. This order to follow is flour, milk, eggs, sugar, butter and cherries, although not all levels have all these ingredients. There are angry chefs around the level that chase the player, although they only care about their favourite ingredient, so only the ones that prefer the next ingredient to be picked up are active at each time. If a chef collides with the player, the player loses.'
}

AVAILABLE_GAMES = list(descriptions.keys())

def log_progress(message: str) -> None:
    print(f'[TRACE] {message}', flush=True)

def build_prompt_standard(observation: str, description_map: Optional[Dict[str, str]]=None) -> str:
    """Construct the default classification prompt with all game descriptions."""
    log_progress('build_prompt_standard: constructing classification prompt')
    description_source = description_map if description_map is not None else descriptions
    num_list = '\n'.join((f'{i}: {g}' for i, g in enumerate(AVAILABLE_GAMES)))
    all_descriptions = 'Here are the descriptions of all the available games, the observations later are from gameplay of one of these games:\n\n'
    for g in AVAILABLE_GAMES:
        desc = description_source.get(g, 'No description available.')
        all_descriptions += f'{g}:\n{desc}\n'
    all_descriptions += 'End of game description\n' + '-' * 40 + '\n'
    return 'You are given 10 consecutive ASCII-rendered game screens produced by random actions in a single game. From their style, symbols, layout, and recurring patterns, deduce which game they come from. Choose exactly one title from the list below.\n\nAvailable games:\n' + num_list + '\n\n' + all_descriptions + 'Answer format (strict):\n{ONLY the selected game name}.\nASCII observations (10 frames):\n```text\n' + observation + '\n```'

# Create sample observation with 10 ASCII frames
sample_observation = "\n".join([
    "Frame 1:",
    "###########",
    "#@  .  #. #",
    "# ## ## # #",
    "# #  #  # #",
    "###########",
    "",
    "Frame 2:",
    "###########",
    "# @  .  #.#",
    "# ## ## # #",
    "# #  #  # #",
    "###########",
] * 5)[:500]  # Truncate to reasonable size

# Build ARGS dict with all parameters
ARGS = {
    'observation': sample_observation,
    'description_map': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
build_prompt_vgdl Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/utils.py
code served (permissive licence) · get_code("848ca2aa57d2f89a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

def log_progress(message: str) -> None:
    print(f'[TRACE] {message}', flush=True)

def build_prompt_vgdl(observation: str):
    """Return a VGDL-authoring chat prompt for VGDL generation jobs."""
    log_progress('build_prompt_vgdl: preparing VGDL prompt')
    system = 'You are an expert in Video Game Description Language (VGDL). Given a short description and a sequence of 10 gameplay observations with actions, infer the minimal VGDL specification.'
    return [{'role': 'system', 'content': system}, {'role': 'user', 'content': observation}]

ARGS = {
    'observation': 'A simple platformer game where the player controls a character that can move left and right, jump to avoid obstacles, and collect coins. Gravity applies downward.'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
clean_and_extract Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/overall_vgdl_results_analysis.py
code served (permissive licence) · get_code("025c14a9021940af")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import tempfile
import re

# Create a temporary file with sample content that matches the expected format
temp_file = tempfile.NamedTemporaryFile(mode='w', suffix='_new_paper_stats.txt', delete=False, encoding='utf-8')

sample_content = """
1. PERFORMANCE METRICS

Overall LLM Win Rates:
| Judge Model | Win Rate | Draw Rate | Loss Rate | Count |
|---|---|---|---|---|
| GPT-4 | 45.50% | 30.25% | 24.25% | 200 |
| Claude | 48.75% | 28.50% | 22.75% | 200 |

2. ANALYSIS

Quantitative Metrics per Level:
| Level | Metric1 | Metric2 | Metric3 | Metric4 |
|---|---|---|---|---|
| Easy | 0.85 | 0.92 | 0.78 | 0.88 |
| Hard | 0.72 | 0.81 | 0.65 | 0.75 |

Aggregated LLM Preference per Level:
| Level | Win Rate | Draw Rate | Loss Rate | Count |
|---|---|---|---|---|
| Easy | 52.00% | 25.00% | 23.00% | 100 |
| Hard | 48.50% | 32.00% | 19.50% | 100 |

Quantitative Metrics per Game:
| Game | Metric1 | Metric2 | Metric3 | Metric4 |
|---|---|---|---|---|
| Chess | 0.91 | 0.87 | 0.89 | 0.85 |
| Checkers | 0.78 | 0.82 | 0.76 | 0.80 |

Aggregated LLM Preference per Game:
| Game | Win Rate | Draw Rate | Loss Rate | Count |
|---|---|---|---|---|
| Chess | 55.00% | 20.00% | 25.00% | 100 |
| Checkers | 46.00% | 37.00% | 17.00% | 100 |

3. ANALYSIS
"""

temp_file.write(sample_content)
temp_file.close()

file_path = temp_file.name

ARGS = {
    'file_path': file_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compare Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/GVGAI_GYM/gym_gvgai/envs/gvgai/check_build.py
code served (permissive licence) · get_code("606ee3293f860d2f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function compare(hash1, hash2) converts both arguments to frozensets
# and checks equality. So hash1 and hash2 should be hashable iterables
# (lists, tuples, sets, etc.) that can be converted to frozensets.

# Create two different hashable iterables
hash1 = [1, 2, 3, 4]
hash2 = [4, 3, 2, 1]

ARGS = {
    "hash1": hash1,
    "hash2": hash2,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_runtime_to_seconds Ran
ran, honoured the contract we drafted
jiwatode-mohit/SCM_4_GVGAI/overall_game_pred_analysis.py
code served (permissive licence) · get_code("97acd8de600ab21b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned int, ndim 0, dtype family int, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

# Test case 1: None input
runtime_str_1 = None

# Test case 2: Simple time format (HH:MM:SS)
runtime_str_2 = "01:30:45"

# Test case 3: Time format with days (D-HH:MM:SS)
runtime_str_3 = "5-02:15:30"

# Test case 4: Zero values
runtime_str_4 = "00:00:00"

# Test case 5: With days and zeros
runtime_str_5 = "2-00:00:00"

ARGS = {
    "runtime_str": runtime_str_2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type int, ndim 0, dtype family int, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
dirHash Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/GVGAI_GYM/gym_gvgai/envs/gvgai/check_build.py
code served (permissive licence) · get_code("a2ce8f3431500582")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import tempfile
import shutil

# Create a temporary directory with some .java files for testing
temp_dir = tempfile.mkdtemp()

# Create some subdirectories and .java files
os.makedirs(os.path.join(temp_dir, "src"), exist_ok=True)
os.makedirs(os.path.join(temp_dir, "src", "subdir"), exist_ok=True)

# Write test .java files
with open(os.path.join(temp_dir, "src", "Test1.java"), "w") as f:
    f.write("public class Test1 { }")

with open(os.path.join(temp_dir, "src", "subdir", "Test2.java"), "w") as f:
    f.write("public class Test2 { }")

# Also write a non-.java file that should be ignored
with open(os.path.join(temp_dir, "src", "readme.txt"), "w") as f:
    f.write("This should be ignored")

ARGS = {
    "dirpath": temp_dir
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ensure_unique_json_path Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/vgdl_gen.py
code served (permissive licence) · get_code("72283c31cce711e8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned PosixPath. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import datetime as dt
from pathlib import Path
import tempfile
import os

# Create a temporary directory for testing
temp_dir = tempfile.mkdtemp()

# Test case 1: Non-existent path
non_existent_path = Path(temp_dir) / "output.json"

# Test case 2: Existing path (create it first)
existing_path = Path(temp_dir) / "existing.json"
existing_path.touch()

# Use the non-existent path as the main test argument
ARGS = {
    "path": non_existent_path
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PosixPath — a PosixPath output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PosixPath output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
fileHash Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/GVGAI_GYM/gym_gvgai/envs/gvgai/check_build.py
code served (permissive licence) · get_code("5ab6d28b05916db8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import tempfile
import os

# Create a temporary file with some content for testing
temp_dir = tempfile.mkdtemp()
test_file = os.path.join(temp_dir, "test.txt")
with open(test_file, 'wb') as f:
    f.write(b"Hello, this is test content for hashing.")

ARGS = {
    'filepath': test_file,
    'blocksize': 4096
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
generate_latex Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/overall_vgdl_results_analysis.py
code served (permissive licence) · get_code("7137ea4bf391d60d")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

ARGS = {
    'title': 'Model Performance Results',
    'headers': ['Metric', 'Value', 'Status'],
    'rows': [
        ['Accuracy', '95.5%', 'Good'],
        ['Loss', '0.045', 'Acceptable'],
        ['F1-Score', '0.92_test', 'Excellent']
    ]
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_src Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/GVGAI_GYM/build.py
code served (permissive licence) · get_code("b9479826c3f56102")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned list, ndim 1, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import tempfile
import shutil

# Create a temporary directory structure with .java files
temp_dir = tempfile.mkdtemp()
os.makedirs(os.path.join(temp_dir, "src", "main", "java"), exist_ok=True)
os.makedirs(os.path.join(temp_dir, "src", "test"), exist_ok=True)

# Create some .java files
with open(os.path.join(temp_dir, "src", "main", "java", "HelloWorld.java"), "w") as f:
    f.write("public class HelloWorld {}")

with open(os.path.join(temp_dir, "src", "main", "java", "Utils.java"), "w") as f:
    f.write("public class Utils {}")

with open(os.path.join(temp_dir, "src", "test", "TestMain.java"), "w") as f:
    f.write("public class TestMain {}")

# Create some non-.java files that should be ignored
with open(os.path.join(temp_dir, "src", "main", "java", "config.xml"), "w") as f:
    f.write("<config></config>")

with open(os.path.join(temp_dir, "README.md"), "w") as f:
    f.write("# Project")

ARGS = {
    "path": temp_dir
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
load_all_results Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/overall_game_pred_analysis.py
code served (permissive licence) · get_code("f2b12fea0b317d6f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned DataFrame. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import json
import tempfile
import shutil

# Create a temporary directory with test JSON files
temp_dir = tempfile.mkdtemp()

# Create sample JSON data matching the expected structure
sample_data_1 = {
    "subsets": {
        "subset_a": {
            "mode_1": {
                "0": {
                    "game_1": {"prediction": "correct_answer"},
                    "game_2": {"prediction": "wrong_answer"}
                }
            }
        }
    }
}

sample_data_2 = {
    "subsets": {
        "subset_b": {
            "mode_2": {
                "0": {
                    "game_3": {"prediction": "correct_answer"},
                    "game_4": {"prediction": "another_answer"}
                },
                "1": {
                    "game_5": {"prediction": "test"}
                }
            }
        }
    }
}

# Write test JSON files
with open(os.path.join(temp_dir, "model_v1@4bit-nf4.json"), "w") as f:
    json.dump(sample_data_1, f)

with open(os.path.join(temp_dir, "model_v2@8bit.json"), "w") as f:
    json.dump(sample_data_2, f)

# Define ARGS with the temporary directory path
ARGS = {
    "folder_path": temp_dir
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
pandas — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DataFrame — a DataFrame output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a DataFrame output the recorded ndim 2 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
parse_model_name Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/overall_game_pred_analysis.py
code served (permissive licence) · get_code("7ac2e253ee8fbfb9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os

def parse_model_name(filename):
    """
    Extracts a distinct model identifier from the filename.
    Treats quantized versions (e.g., 4bit-nf4) as separate models.
    """
    base = os.path.basename(filename)
    name_part = os.path.splitext(base)[0]
    if '@' in name_part:
        parts = name_part.split('@')
        base_model = parts[0]
        try:
            if '__' in base_model:
                base_model = base_model.split('__')[1]
        except IndexError:
            pass
        suffix = parts[1]
        quant_markers = ['4bit', '8bit', 'nf4', 'gguf', 'awq', 'gptq', 'int4', 'int8', 'q4', 'q8']
        found_quants = [marker for marker in quant_markers if marker in suffix.lower()]
        if found_quants:
            quant_tag = suffix.replace('w_description', '').strip('_').strip('-')
            if quant_tag:
                return f'{base_model} ({quant_tag})'
        return base_model
    return name_part


ARGS = {
    'filename': '/path/to/model_name@4bit-nf4.bin'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
none outside the standard library — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
strip_description_prefix Ran
ran; our contract draft was wrong, not the code
jiwatode-mohit/SCM_4_GVGAI/utils.py
code served (permissive licence) · get_code("cc890a1286667b40")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned str. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

def log_progress(message: str) -> None:
    print(f'[TRACE] {message}', flush=True)

DESCRIPTION_SEPARATOR = 'End of game description\n----------------------------------------\n'

def strip_description_prefix(text: str) -> str:
    """Remove the prepended description section from cached observations."""
    log_progress('strip_description_prefix: inspecting observation text')
    if not text:
        return text
    if DESCRIPTION_SEPARATOR in text:
        _, remainder = text.split(DESCRIPTION_SEPARATOR, 1)
        return remainder.lstrip('\n')
    return text

ARGS = {
    'text': 'End of game description\n----------------------------------------\nThis is the remainder of the observation.'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_game_description Not yet run
unverified (harvested, no recorded run)
jiwatode-mohit/SCM_4_GVGAI/vgdl_gen.py
code served (permissive licence) · get_code("252a4a7a15731a27")
How it ran

no invocation recorded.

read_ground_truth_vgdl Not yet run
unverified (harvested, no recorded run)
jiwatode-mohit/SCM_4_GVGAI/vgdl_gen.py
code served (permissive licence) · get_code("e1ab6ecf3146b00c")
How it ran

no invocation recorded.

Also present in other papers' code

Of 15 samples lifted from this paper's linked repositories, 15 carry a function identity and 0 do not. Of the 15 distinct functions with an identity, 4 are also present in other papers whose code we hold (4 with at least one paper dated earlier, 0 the same month, 0 later) and 11 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
compare 1 other paper
1 dated earlier
1806.02448 (2018-06)
Deep Reinforcement Learning for General Video Game AI
dirHash 1 other paper
1 dated earlier
1806.02448 (2018-06)
Deep Reinforcement Learning for General Video Game AI
fileHash 1 other paper
1 dated earlier
1806.02448 (2018-06)
Deep Reinforcement Learning for General Video Game AI
get_src 1 other paper
1 dated earlier
1806.02448 (2018-06)
Deep Reinforcement Learning for General Video Game AI

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Deep learning agents can achieve high performance in complex game domains without often understanding the underlying causal game mechanics. To address this, we investigate Causal Induction: the ability to infer governing laws from observational data, by tasking Large Language Models (LLMs) with reverse-engineering Video Game Description Language (VGDL) rules from gameplay traces. To reduce redundancy, we select nine representative games from the General Video Game AI (GVGAI) framework using semantic embeddings and clustering. We compare two approaches to VGDL generation: direct code generation from observations, and a two-stage method that first infers a structural causal model (SCM) and then translates it into VGDL. Both approaches are evaluated across multiple prompting strategies and controlled context regimes, varying the amount and form of information provided to the model, from just raw gameplay observations to partial VGDL specifications. Results show that the SCM-based approach more often produces VGDL descriptions closer to the ground truth than direct generation, achieving preference win rates of up to 81% in blind evaluations and yielding fewer logically inconsistent rules. These learned SCMs can be used for downstream use cases such as causal reinforcement learning, interpretable agents, and procedurally generating novel but logically consistent games.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2602.00190")
get_code_for_paper("2602.00190")
have("2602.00190")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2602.00190.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2602.00190.svg)](https://syntology.ai/paper/2602.00190)

Connect an agent — have() is free.