projenix/tinysynth-reasoning

TinySynth Reasoning Primitives

Synthetic training data for teaching small language models stable state representation and controlled reasoning operations — entity/attribute binding, state persistence, mutation, transfer, reference resolution, current-vs-cumulative distinctions, and claim validation — in a systems/computing vocabulary.

Every example is generated from a hidden symbolic world and verified by a symbolic solver before any natural language is produced:

semantic state schema -> symbolic world -> symbolic events -> solver
    -> known final + intermediate states -> structural validation -> rendering

Language only ever renders already-verified truth; it never determines the answer. Nouns and verbs are not mixed freely — each state variable owns the verbs that may act on it, so semantically broken text like "3 stored files finish" is unproducible by construction rather than filtered out afterwards.

Configs = curriculum levels

One config per difficulty level, intended to be trained in order.

Config	Examples	Approx. tokens	Primitives
difficulty_0	797,391	~20,000,080	containment, mapping, membership, retrieval
difficulty_1	553,128	~20,000,058	decrement, increment, noop_contrast, replace, state_persistence, toggle
difficulty_2	485,859	~20,000,038	attribute_binding, boolean_logic, comparison, conditional, contradiction, counting_selected, current_vs_cumulative, entity_binding, equality, event_classification, irrelevant_filter, ordering, reference_resolution, state_persistence, transfer, validation
difficulty_3	459,909	~20,000,055	accumulation, multi_step
difficulty_4	361,059	~20,000,060	contradiction, current_vs_cumulative, irrelevant_filter, reference_resolution, state_persistence, transfer
difficulty_5	265,089	~20,000,126	cross_entity, reference_resolution

Difficulty is computed from latent features (transitions, entities, references, distractors, no-ops, conditions), not from sentence count — a long arithmetic chain does not automatically score high.

Level	Content
0	Pure retrieval / lookup, no events
1	One state operation, or pure observation (no-ops only)
2	One operation + one complication
3	2-4 clean state transitions
4	Multiple transitions + exactly one complication
5	Multiple transitions + two or more complications

Usage

from datasets import load_dataset

ds = load_dataset("sam/tinysynth-reasoning", "difficulty_0")
print(ds["train"][0]["text"])

Train on the text field. To walk the curriculum:

for level in range(6):
    ds = load_dataset("sam/tinysynth-reasoning", f"difficulty_{level}")
    train(ds["train"])

Recover the symbolic ground truth for analysis or programmatic grading:

import json
latent = json.loads(ds["train"][0]["latent_state"])
# {'initial': {...}, 'events': [...], 'final': {...}, 'query': {...}}

Splits

Split	Purpose
train	Training data.
validation	Held-out, same distribution.
test	Held-out, same distribution.
ood_test	Generalization split. Same reasoning primitives, but held-out wording, entity names, schema/entity-kind pairings, and one surface form (state_transition) reserved exclusively for it. Measures whether the model learned the operation or memorized the template.

Splits are assigned per latent problem, so every surface variant of a problem stays in one split — there is no leakage between splits even though the same underlying world may be rendered several ways.

Fields

Field	Type	Description
id	string	Unique id: <latent_problem_id>_<surface_form>.
latent_problem_id	string	Id of the underlying symbolic problem. All surface variants of one problem share it and always land in the same split.
primitive	string	Reasoning primitive exercised (validated structurally, not just labelled).
subprimitive	string	Finer variant, e.g. mutation_among_no_ops, irrelevant_events_other_entity. May be null.
difficulty	int64	Curriculum level 0-5, computed centrally from latent features.
surface_form	string	Rendering style, e.g. natural_qa, compact_reasoning, stepwise_state.
wording_template	string	<primitive>/<surface_form>, for slicing accuracy by template.
domain	string	Entity kind, e.g. server, cache, message queue.
state_schema	string	Semantic state variable, e.g. active_jobs, queued_requests. May be null for schema-less primitives.
split	string	Split this row belongs to (also encoded by the file it lives in).
contrast_group_id	string	Set on minimal-pair examples (observation vs mutation) that share a setup. May be null.
entity_count	int64	Number of entities carrying state.
attribute_count	int64	Number of distinct tracked attributes.
transition_count	int64	Number of state-changing events.
noop_count	int64	Number of observation (no-op) events.
reference_count	int64	Number of anaphoric references.
distractor_count	int64	Number of irrelevant facts.
prompt	string	Model input.
answer	string	Target completion.
text	string	prompt + "\n\n" + answer — the field to train on.
latent_state	string	JSON string: {initial, events, final, query} — the symbolic ground truth the example was generated from.

latent_state is a JSON string rather than a nested struct on purpose: its keys are entity-specific (host_1.running_containers, ...), so an inferred Arrow struct would carry hundreds of mostly-null columns and would not be stable across shards or datasets versions.

Generation

python -m tinysynth.hf_export --output-dir tinysynth-reasoning \
    --target-tokens-per-level 20000000 \
    --seed 42 --variants-per-problem 3 \
    --ood-fraction 0.05

Generation is deterministic for a fixed seed and configuration.

Design notes and limitations

• Observation is not mutation. A large share of the corpus trains explicitly on the fact that checking, reading, listing, or displaying state leaves it unchanged, including minimal pairs (contrast_group_id) whose setups are identical apart from one verb.
• Similar nouns are distinguished. queued_requests and total_requests_received are different variables; an arrival increments both, a completion decrements only the first.
• Anaphora appear only where the antecedent is adjacent and unambiguous, so hard coreference is out of scope by design.
• Conditionals are single-clause threshold checks; there is no nested depth.
• Numbers are small (0-9 by default) on purpose — the target is reasoning mechanics, not arithmetic difficulty.
• The ood_test split varies surface realization only, not reasoning structure; it measures template memorization, not compositional generalization.