💬 NLP

Can Large Language Models Generalize Procedures Across Representations?

This paper demonstrates that a two-stage reinforcement learning curriculum, which sequentially trains large language models on symbolic data (code/graphs) followed by natural language, enables effective cross-representation generalization of procedural tasks, allowing a small 1.5B model to match the zero-shot planning performance of GPT-4o.

Original authors: Fangru Lin, Valentin Hofmann, Xingchen Wan, Weixing Wang, Zifeng Ding, Anthony G. Cohn, Janet B. Pierrehumbert

Published 2026-06-04

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Fangru Lin, Valentin Hofmann, Xingchen Wan, Weixing Wang, Zifeng Ding, Anthony G. Cohn, Janet B. Pierrehumbert

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are teaching a robot how to bake a cake. You have three ways to give it instructions:

Natural Language: A recipe written in a book ("Mix flour, then add eggs...").
Code: A computer program that lists the steps and timing.
Graph: A flowchart with arrows showing which step must happen before the next.

The big question this paper asks is: If you teach the robot using the flowchart (Graph) or the code, will it automatically know how to follow the written recipe (Natural Language)?

The researchers found that the answer is mostly no.

The Problem: The "Language Barrier"

The authors discovered that Large Language Models (LLMs) are like students who are very good at memorizing the format of the instructions but bad at understanding the logic behind them.

The "Single-Format" Trap: If you train a robot only on flowcharts, it becomes a master of flowcharts. But if you then ask it to solve a problem using a written recipe, it gets confused. It doesn't realize that "Step A must happen before Step B" in a flowchart is the exact same rule as "First, do A, then do B" in a sentence.
The "Lazy" Shortcut: When the robot tries to guess the answer in a new format, it often takes a lazy shortcut. Instead of figuring out the complex order of steps (the "critical path"), it just adds up all the times together. It's like someone trying to figure out the fastest route to work by adding up the time of every possible road, rather than finding the actual shortest path.

The Solution: A Two-Stage Training Camp

Since the robot couldn't just "figure it out" on its own, the authors designed a special training curriculum (a lesson plan) to fix this. Think of it like learning a musical instrument:

Stage 1: The Math Class (Symbolic Training): First, they teach the robot using the "hard" formats (Code and Flowcharts). This forces the robot to learn the strict, logical rules of the procedure without getting distracted by fancy words. It's like learning the theory of music before trying to play a song.
Stage 2: The Jam Session (Natural Language Adaptation): Once the robot understands the logic, they switch to teaching it using natural language (the recipe). Because the robot already knows the rules from Stage 1, it can now apply them to the new language.

The Result: This two-step method worked wonders. A small robot (1.5 billion parameters) trained this way performed almost as well as a massive, super-smart robot (GPT-4o) that had never seen this specific training before.

The Secret Ingredient: "Generative Analogy"

Why did this work? The paper suggests the robot learned to use generative analogy.

Frequency vs. Analogy:
- Frequency is like memorizing that "King + Queen = Royal" because you saw it a million times.
- Analogy is understanding the relationship between the words so you can apply it to new things (e.g., "Doctor + Nurse = Hospital Team").
The researchers found that the successful robots weren't just memorizing patterns; they were building a mental bridge. They realized, "Oh, this flowchart structure is analogous to this sentence structure." The two-stage training forced them to build that bridge.

The Catch: It's Not Magic (Yet)

The paper makes an important distinction between robots and humans:

Humans are like geniuses who can look at a flowchart once and immediately understand how to write the recipe. We generalize instantly.
Robots are like diligent students who need to practice the logic in one format for a long time before they can successfully apply it to another. They need that "extra homework" (the two-stage training) to make the connection.

Summary

The paper proves that simply training AI on code or graphs doesn't automatically make it good at natural language tasks. However, if you train it on the logic first (using code/graphs) and then teach it the language, it can learn to translate those logical rules into human speech. This turns the AI from a pattern-memorizer into a true problem-solver that can understand the "why" behind the steps, not just the "what."

Technical Summary: Can Large Language Models Generalize Procedures Across Representations?

Problem Statement

Large Language Models (LLMs) are extensively trained on symbolic representations such as code and graphs, yet real-world user tasks are predominantly specified in natural language (NL). A critical, underexplored capability for robust LLMs is cross-representation generalization: the ability to transfer procedural knowledge learned in one representation (e.g., code or graphs) to solve tasks specified in another (e.g., natural language).

Existing research often conflates surface-level representational factors with deeper structural ones, failing to isolate whether symbolic training aids or hinders natural language reasoning. Furthermore, while cognitive science identifies generative analogy—the ability to map learned structures across representations by aligning shared underlying structures—as a core human reasoning mechanism, LLMs are primarily studied on proportional analogies with high surface similarity. This paper investigates whether LLMs can generalize procedures across isomorphic tasks presented in natural language, graphs, and code, and if not, how to bridge this gap.

Methodology

Experimental Setup

The authors constructed a controlled experimental setting using isomorphic tasks where the underlying algorithm remains identical, but the surface representation varies. The primary task is asynchronous planning (scheduling steps with dependencies and time durations), formalized as finding the longest path (critical path) in a Directed Acyclic Graph (DAG).

Natural Language (NL): Tasks described as step-by-step instructions with dependencies (e.g., "Step 1 must precede Step 3").
Graph: Tasks represented as adjacency lists and node weights.
Code: Tasks represented as Python snippets implementing DAG longest-path algorithms with specific inputs.

The study evaluated three model families (Qwen-2.5, Llama-3, Olmo-2) across various scales (1.5B to 7B parameters) using four post-training strategies:

Vanilla SFT: Fine-tuning on prompt-answer pairs without Chain-of-Thought (CoT).
Distillation: Training on CoT reasoning generated by a stronger teacher model (DeepSeek-R1-Distill-Qwen-32B).
STaR (Self-Taught Reasoner): A bootstrapping method where the model trains on its own correct generations.
GRPO (Group Relative Policy Optimization): A reinforcement learning method using verifiable outcome rewards.

Proposed Solution: Two-Stage RL Curriculum

To address the observed failure of single-representation training, the authors propose a two-stage reinforcement learning curriculum:

Stage 1 (Symbolic Induction): Train the model on symbolic data (Graph or Code) to learn abstract procedures.
Stage 2 (Natural Language Adaptation): Continuously train the model on Natural Language data to adapt the learned procedures to the target representation.

This approach separates the learning of abstract structure from surface form adaptation.

Key Results

1. Failure of Naive Cross-Representation Generalization

Symbolic to NL: Training solely on Graph or Code data yields high performance within those representations but fails to generalize to NL tasks. Performance often collapses under representation shifts, even when the underlying logic is identical.
NL to Symbolic: Training solely on NL data leads to inefficient performance gains and does not reliably transfer to symbolic tasks.
Method Comparison: While GRPO and Distillation show strong within-reperformance, they do not inherently solve the cross-representation gap. Scaling model parameters (e.g., from 1.5B to 7B) does not qualitatively change this failure pattern; larger models often exhibit a sharper drop in out-of-distribution performance.

2. Efficacy of the Two-Stage Curriculum

Performance Gains: The Graph $\to$ NL curriculum substantially improves performance. A 1.5B Qwen model trained with this curriculum outperforms its 7B variant trained only on NL and matches the zero-shot performance of GPT-4o on the asynchronous planning task.
Robustness: The curriculum demonstrates robustness to linguistic variations, outperforming baselines on NL-AAVE (African American Vernacular English), a dialect variant that challenges frontier models.
Order Sensitivity: The order of training is critical. Reversing the curriculum (NL $\to$ Graph) performs worse than training on NL alone, indicating that symbolic induction is necessary to establish the structural foundation before adaptation.
Generalization: The curriculum's benefits extend beyond planning to Math and Physics tasks, showing improved generalization across domains.

3. Mechanism of Generalization: Generative Analogy

The authors analyze whether success is driven by data frequency or structural similarity (analogy).

Correlation Analysis: Using structure-mapping theory, they quantify "analogical strength" between training and test instances. Results show that successful cross-representation generalization correlates significantly more with high analogical strength (structural similarity) than with the frequency of similar training instances.
Qualitative Evidence: Models trained with the curriculum exhibit more systematic reasoning (iterating through multiple paths to find the longest) compared to "lazy reasoning" or simple summation observed in models trained only on NL or Graph alone.

Significance and Claims

The paper claims that while LLMs possess the capacity to generalize across representations, they do not do so naturally through standard post-training methods. Instead, this capability must be cultivated through specific curricula.

Generative Analogy: The study interprets successful cross-representation generalization as a form of generative analogy, where the model aligns shared underlying structures rather than memorizing surface patterns. The proposed curriculum effectively encourages this analogical behavior.
Training Requirements: Unlike human analogical reasoning, which can generalize with minimal exposure, LLMs require extended training in the new representations (via the adaptation stage) to effectively utilize the abstract procedures learned in the symbolic stage.
Limitations: The authors note that despite the improvements, a performance gap remains between standard NL and dialect variants (NL-AAVE), highlighting ongoing challenges in technological fairness. Additionally, the paper does not claim that scaling representations at training time alone will solve the problem, as single-representation scaling failed to produce transfer.

In conclusion, the work demonstrates that a structured, two-stage RL curriculum can bridge the gap between symbolic and natural language reasoning, enabling smaller models to achieve performance levels comparable to much larger, zero-shot models on complex procedural tasks.