Dolevabudi/graph-serialization-invariance-full

Graph Serialization Invariance of LLM Code Generation

This dataset holds the data behind the course project How Invariant is Code Generation to Graph Serialization? (Machine Learning with Graphs, 2026; Ram Kedem, Yehonatan Barel, Ido Azoulay, Dolev Abudi).

Research question. An LLM can solve a graph problem by writing a program instead of answering directly. Does it return the same answer when the same graph is written down differently? If not, where does the fragility enter: when the model copies the graph into its program, or in the program's logic?

What is here. The benchmark instances and every serialization of them. Every prompt that was sent, and every reply from four models. Each generated program with its execution outcome and score. The analysis tables behind each number in the report. Every table in results/ was recomputed from the records in data/ before release, and they match.

Experimental design

Benchmarks	GraphQA: 700 instances (100 graphs × 7 tasks, 5-20 nodes, generated with the Talk Like a Graph generators, seed 0). Erdős: 1,200 instances (12 tasks × 100, 4-34 nodes, from the PKU-ML/Erdos test split)
Serializations	Each instance is rendered in a reference form and in forms that differ along one axis. relabel: 3 random node relabelings plus the sorted identity. order: 3 edge orders. structure: adjacency list, or each edge listed in both directions. syntax: plain text, JSON, NetworkX code. In total 8,925 forms for GraphQA and 14,246 for Erdős
Conditions	direct: answer in text. code: write a program from a fixed template. graph_as_code: the same template with the graph pre-filled by the harness, so the model never sees the graph text. Both code conditions run in a native arm (plain Python) and a networkx arm (NetworkX permitted)
Models	Qwen3-8B, DeepSeek-V3.1, Gemma 4 31B and DeepSeek-V4-Flash, via Hugging Face Inference Providers at temperature 0
Execution	Each program runs in an isolated subprocess (20 s, 1 GB) against the graph of its form. The answer is mapped back to the original labels and compared with the ground truth
Metrics	Per instance and axis. I (consistency): all forms give the same answer; an unparsable answer never counts as agreement. R: all forms are correct. Also accuracy, and failure classes (transcription, construction, execution, logic, ...)

model value	model	provider	run date
hf-qwen3-8b-nscale	Qwen/Qwen3-8B	nscale	2026-09-17
hf-deepseek-v3.1-novita	deepseek-ai/DeepSeek-V3.1	novita	2026-09-18
hf-gemma-4-31b	google/gemma-4-31B-it	novita	2026-09-19
hf-deepseek-v4-flash	deepseek-ai/DeepSeek-V4-Flash	deepinfra	2026-09-19

Contents

data/: records (Parquet; each config is split by benchmark)

config	rows (GraphQA / Erdős)	one row is
records	178,500 / 284,920	one model's answer for one form of one instance in one condition: prompt hash, reply, extracted program, parsed answer, correctness, failure class and diagnostics. The main experiment
instances	700 / 1,200	a graph, a task, a query and its ground truth
variants	8,925 / 14,246	one serialization of an instance: its axis, parameters, label map and the graph text shown to the model
prompts	44,740 / 43,743	the exact system and user text of a prompt, keyed by prompt_hash (SHA-256 of both), for every prompt in this dataset
graph_type_rerun	- / 113,968	the graph_as_code condition on Erdős rerun with the graph type stated in the prompt
canonical_labeling	16,000 / 6,000	mitigation: the model re-asked on a canonically relabeled prompt (schemes canonical, degree_wl, bfs_min)
solver_per_task	71,400 / 113,968	mitigation: one program per task, written without a graph, executed on every form
noise_floor_replies	5,178 / 8,652	repeat asks (repeat 1-3) of identical prompts; ask 0 is the reply in records
prompt_hint_replies	33,040 / -	replies to prompts with a one-sentence hint (duplicate edges, or "no direct edge" wording); Qwen3-8B and DeepSeek-V3.1

results/: the analysis tables the report cites (CSV, JSON)

main_experiment/<benchmark>/   accuracy, invariance (I and R), gap (code minus graph_as_code),
                               ladder (syntax forms), failures, silent_transcription
main_experiment/paired_intervals.csv   paired bootstrap 95% intervals (5,000 resamples)
graph_type_rerun/              compare/ (before vs after stating the graph type), ablation/
mitigation/noise_floor/        repeated-prompt floor next to the observed flip rates
mitigation/detection_and_answer_vote/  disagreement across forms as an error detector; answer vote; abstention
mitigation/canonical_labeling/ accuracy vs random labels; prompt invariance of each scheme
mitigation/solver_per_task/    accuracy and consistency of one program per task
mitigation/program_voting/     voting over the programs of all forms, run on one graph
mitigation/prompt_hint/        the duplicate-edge and "no direct edge" wording hints

Where the report's numbers come from

report	file
Table 1 (I and R per model, condition, benchmark)	results/main_experiment/<benchmark>/invariance.csv (mean over tasks, relabel and order axes)
Significance of differences	results/main_experiment/paired_intervals.csv
Repeated-prompt floor	results/mitigation/noise_floor/<benchmark>.json
Structure and syntax effects; duplicate-edge degree; NetworkX cost	results/main_experiment/<benchmark>/{invariance,accuracy,failures}.csv
Transcription vs solving	records (declared_ok, construction_ok, correct), silent_transcription.csv
Unstated graph type in graph_as_code	results/graph_type_rerun/, graph_type_rerun
Table 2 (detector) and answer vote	results/mitigation/detection_and_answer_vote/
Program vote, canonical labeling, one solver per task	results/mitigation/{program_voting,canonical_labeling,solver_per_task}/
Duplicate-edge hint	results/mitigation/prompt_hint/, prompt_hint_replies

Using the data

from datasets import load_dataset

records = load_dataset("Dolevabudi/graph-serialization-invariance-full", "records", split="erdos")
prompts = load_dataset("Dolevabudi/graph-serialization-invariance-full", "prompts", split="erdos")

Useful joins: records.variant_id → variants.variant_id; records.instance_id → instances.id; prompt_hash → prompts.prompt_hash.

Fields of records (also used by graph_type_rerun, canonical_labeling and solver_per_task):

field	meaning
mode, library	condition: direct / code / graph_as_code, arm native / networkx (null for direct)
axis, params	which serialization the form varies, and how
response, code	the model's reply and the program extracted from it
parsed_canonical, answer_key	the answer mapped back to the original labels; the key compared across forms
correct, failure_class	verdict; ok, wrong, execution, format, transcription, construction, logic, no_computation, unverifiable
declared_ok	the nodes and edges written into the program equal the graph it was shown
construction_ok	the graph the program built equals what it declared (NetworkX arm only)
error, timed_out, exit_code	execution outcome; error is the last line of the exception
finish_reason	length means the reply was cut off

Fields that can hold values of several types (ground_truth, parsed, parsed_canonical, params, edges, query_args, meta, label_map) are stored as JSON strings.

Notes for interpretation

• Records are not independent calls. A graph_as_code prompt contains no graph text, so many records can share one reply. Each model made 24,942 distinct calls on GraphQA and 40,682 on Erdős. The tables report n (records) next to n_calls.
• Do not pool failure classes across library. construction is observable only in the NetworkX arm.
• Hidden prompt suffixes. Qwen3-8B received /no_think appended on the wire, which is not part of the stored prompt or its hash. Gemma and DeepSeek-V4-Flash had thinking disabled through the chat template.
• Subsets. Canonical labeling uses a fixed-stride subset: 400 GraphQA and 150 Erdős instances. Program voting uses 300 instances per benchmark, and the noise floor 100 stratified instances.
• Solver per task. A fixed adapter drops a solver's own top-level call and returns an assigned but unreturned ans. It changes 17 Qwen3-8B programs.
• Prompt hints. These ran later and on another machine than the baseline, so provider drift cannot be excluded.
• Outside source. Gemma 4 31B and DeepSeek-V4-Flash ran on a teammate's machine. Their records are the ones published in Yonibarel/graph-serialization-invariance (revision 8e1c186).

License and sources

Released under MIT. Erdős instances derive from PKU-ML/Erdos (Apache-2.0; Guo et al., G1: Teaching LLMs to Reason on Graphs with Reinforcement Learning). GraphQA graphs follow Fatemi et al., Talk Like a Graph: Encoding Graphs for Large Language Models (ICLR 2024). Model outputs remain subject to their providers' terms.