Yonibarel/graph-serialization-invariance

Serialization-invariance audit of LLM graph code generation

Does an LLM that solves a graph problem by writing code return the same answer under equivalent serializations of the same graph -- and if not, does the fragility enter when it transcribes the graph into its program, when it constructs a structure from that copy, or in the solution logic?

Produced by ml_graphs at commit 73f956e.

Design

Each instance (one graph + one task + one query) is rendered into several equivalent serializations differing in exactly one axis: relabel, order, structure, syntax. Every variant is put to the model in three modes, two of them crossed with a solving library:

mode	graph arrives as	transcribes?	library arms
direct (M1)	text	--	none
code (M2)	text + a fixed program template	yes	networkx, native
graph_as_code (M3)	nodes/edges pre-filled by the harness	no	networkx, native

M2 and M3 are a minimal pair: the same template, differing only in who fills the two declaration lines. The M2-M3 difference is therefore the cost of transcription alone.

Models

• hf-deepseek-v3.1-novita
• hf-deepseek-v4-flash
• hf-gemma-4-31b
• hf-qwen3-8b-nscale

Both served through HuggingFace Inference Providers at temperature 0. The provider is part of the identity: the same Qwen3-8B degenerated on 29% of prompts on one provider and 0% on another (see the repo's docs/pipeline-and-caching.md).

Files

tables/<dataset>/accuracy.csv             mean(correct) per dataset x task x mode x library x axis x model
                 invariance.csv           frac_identical -- the headline metric, per instance then aggregated
                 gap.csv                  M2 - M3 invariance, within a library arm = the cost of transcription
                 ladder.csv               failure shares across prose -> json -> networkx code -> injected
                 failures.csv             failure-class decomposition among code-mode failures
                 silent_transcription.csv wrong graph, right answer
tables/<dataset>/<model>/*.csv            model-specific exports from analysis with --models
figs/<dataset>/*.png                      the same, plotted, one file per model
scored/<dataset>/<model>.jsonl.gz         one row per record: every intermediate + the verdict
data/<dataset>/instances.jsonl            which graphs, tasks and queries were sampled

Reading scored/

One row per (instance, variant, mode, library, model). Beyond correct and failure_class it carries the diagnostics that make attribution possible:

field	meaning
declared_ok	the nodes/edges the model wrote == the graph it was shown (transcription)
construction_ok	the graph the program built == what it declared (networkx arm only)
ans_is_literal	ans was written down, not computed
finish_reason	length = the reply was cut off; exclude these before quoting invariance
n_calls (tables)	distinct model replies behind a cell

n is not n_calls. M3's prompt contains no graph text, so for a task whose question names no node (cycle_check, node_count, density, ...) every instance and variant collapses to one reply, executed against every graph. Such a cell can hold 1,000 rows backed by a single model decision -- read n_calls before quoting it.

Failure classes

ok wrong execution format transcription construction logic no_computation unverifiable -- defined in the repo's docs/scoring-and-classification.md. construction is separable in the networkx arm only, so never pool the failure decomposition across library.