license: other
language:
- en
tags:
- LOOM
- English
- CoT
- code
- math
LOOM: Language-Only Operational Microworlds
LOOM is a synthetic natural-language reasoning dataset designed to teach language models the deep structures behind code and math without exposing source code, formal equations, or symbolic programming syntax.
Instead of showing code or math notation, LOOM trains models on ordinary-language microworlds where the hidden logic is algorithmic: state changes, causal chains, conditionals, invariants, iteration, and reverse reasoning.
The dataset is intended as a pre-code / pre-math reasoning substrate. It teaches the model to simulate rules, track hidden states, infer causes, and produce step-by-step logical traces.
What LOOM Teaches
LOOM examples are designed to implicitly train the following skills:
- State tracking: following how objects change across events.
- Causal chaining: propagating effects through multiple rules.
- Conditionals: reasoning through if/else-style branches.
- Invariants: understanding conserved quantities or balanced properties.
- Iteration: reasoning about repeated actions until completion.
- Reverse reasoning: inferring causes from observed outcomes.
- Chain-of-thought traces: producing intermediate reasoning before the final answer.
What LOOM Avoids
The dataset intentionally avoids:
- Source code
- Programming syntax
- Formal equations
- Mathematical notation
- Code-like operators
- Formulaic symbolic reasoning
The surface text is plain natural language. The computational and mathematical structure remains latent.
Dataset Structure
Each example is a JSONL object with the following fields:
instruction: The task prompt.world: The rules describing the microworld.event: The triggering event or observed state.question: What the model must infer.reasoning: A step-by-step natural-language logical trace.final_answer: The final outcome.
Example
{
"instruction": "Determine the outcome of the event based on the world rules. Provide a step-by-step logical trace before the final answer.",
"world": "Whenever the silver mirror reflects, it triggers the dormant shadow. Whenever the dormant shadow awakens, it triggers the golden seed.",
"event": "The silver mirror reflects.",
"question": "What is the final consequence for the golden seed?",
"reasoning": "First, the silver mirror reflects. Because the silver mirror reflected, the dormant shadow is triggered. Because the dormant shadow awakened, the golden seed is triggered.",
"final_answer": "The golden seed is triggered."
}
Categories
1. Causal Chains
Teaches transitive reasoning and state propagation.
Example pattern:
Whenever A acts, it triggers B.
Whenever B acts, it triggers C.
A acts.
Therefore, C is triggered.
2. Conditionals
Teaches branching logic.
Example pattern:
If A happens, B happens.
If A does not happen, C happens.
3. Invariants
Teaches conservation-style reasoning.
Example pattern:
The total balance between A and B is preserved.
If A gains something, B must lose it.
4. Iteration
Teaches repeated actions, termination conditions, and cumulative effects.
Example pattern:
The ritual repeats until the required number of actions has occurred.
5. Reverse Logic
Teaches abduction and backtracking.
Example pattern:
The outcome happened.
What must have caused it?
Loading the Dataset
from datasets import load_dataset
ds = load_dataset(
"YOUR_USERNAME/loom",
data_files={"train": "loom_dataset.jsonl"},
split="train",
)
print(ds[0])
Replace YOUR_USERNAME with your Hugging Face username.
Intended Use
LOOM can be used for:
- Reasoning-focused continued pretraining
- Chain-of-thought style supervision
- Synthetic reasoning warm-up before code or math training
- Evaluation of rule-following and hidden-state tracking
- Data augmentation for abstract reasoning tasks
It is not intended to replace real code or math datasets. It is intended to teach the underlying operational reasoning that makes those domains easier to learn.
Generation
This dataset was procedurally generated using combinatorial natural-language templates. Each example is constructed from randomized entities, actions, conditions, and causal relations.
The generation process creates millions of unique examples while preserving logical consistency between:
- the world rules,
- the event,
- the reasoning trace,
- and the final answer.
Limitations
LOOM is synthetic and stylized. Its language is intentionally simple and rule-based. It may contain repeated structures, artificial phrasing, and limited semantic diversity compared with natural web text.
The dataset teaches abstract reasoning patterns, but it does not teach real programming syntax, libraries, APIs, or advanced mathematical formalism.
Citation
@misc{loom2026,
title={LOOM: Language-Only Operational Microworlds},
author={Gugu8},
year={2026},
howpublished={Hugging Face Datasets}
}