Source-linked AI summary
Learn2Fold: Structured Origami Generation with World Model Planning
Yanjia Huang, Yunuo Chen, Ying Jiang, Jinru Han, Zhengzhong Tu, Yin Yang, Chenfanfu Jiang
TL;DR
Valid origami generation remains difficult because sparse semantic inputs must be converted into long-horizon folding programs that obey hard geometric constraints. Learn2Fold combines LLM proposals, graph-structured world-model lookahead, and symbolic verification, reporting strong validity and trajectory results across its evaluation settings.
Problem
Origami generation must produce executable long-horizon action sequences over discrete topology and continuous geometry while satisfying strict physical constraints.
Method
Learn2Fold performs constraint-aware program induction over a crease-pattern graph, using an LLM for structured proposals, a graph world model for lookahead, and symbolic verification.
Results
Learn2Fold outperforms all baselines across step-level accuracy and trajectory-level success, achieving F1µ = 0.739 versus GPT-5.1’s 0.266.
Takeaways & Limitations
The framework unifies semantic reasoning with rigorous geometric constraint enforcement for physically valid origami process generation.
Abstract
from arXiv · showhide
The ability to transform a flat sheet into a complex three-dimensional structure is a fundamental test of physical intelligence. Unlike cloth manipulation, origami is governed by strict geometric axioms and hard kinematic constraints, where a single invalid crease or collision can invalidate the entire folding sequence. As a result, origami demands long-horizon constructive reasoning that jointly satisfies precise physical laws and high-level semantic intent. Existing approaches fall into two disjoint paradigms: optimization-based methods enforce physical validity but require dense, precisely specified inputs, making them unsuitable for sparse natural language descriptions, while generative foundation models excel at semantic and perceptual synthesis yet fail to produce long-horizon, physics-consistent folding processes. Consequently, generating valid origami folding sequences directly from text remains an open challenge. To address this gap, we introduce Learn2Fold, a neuro-symbolic framework that formulates origami folding as conditional program induction over a crease-pattern graph. Our key insight is to decouple semantic proposal from physical verification. A large language model generates candidate folding programs from abstract text prompts, while a learned graph-structured world model serves as a differentiable surrogate simulator that predicts physical feasibility and failure modes before execution. Integrated within a lookahead planning loop, Learn2Fold enables robust generation of physically valid folding sequences for complex and out-of-distribution patterns, demonstrating that effective spatial intelligence arises from the synergy between symbolic reasoning and grounded physical simulation.
1. Introduction
Origami exposes the limits of generative models because valid folding requires long-horizon reasoning under strict geometric and topological constraints. Learn2Fold addresses this by combining language-based semantic proposals with learned and symbolic physical verification.
- Origami folding transforms a flat sheet into a 3D structure under strict geometric and topological constraints, so a misplaced crease can invalidate the process.
- Existing generative models produce descriptive or high-level folding guidance but typically fail to generate physically executable processes.
- Optimization-based origami methods provide simulation-ready, physically grounded crease patterns but require precise 3D mesh inputs, limiting sparse text or image conditioning.
- Learn2Fold formulates origami generation as constraint-aware program induction and separates semantic proposal from physical verification.
- An LLM proposes structured actions, a graph-structured world model performs differentiable lookahead, and a symbolic simulator applies exact final feasibility checks.
- The framework combines semantic action proposal, physics-aware planning, scalable simulation-driven data curation, and reported generalization to out-of-distribution physically valid generation.
2. Related Work
Origami generation requires executable long-horizon planning over hybrid discrete-continuous states with hard validity constraints. Prior methods provide either perceptual proposals, forward simulation, or geometry-centric optimization, motivating Learn2Fold’s graph-grounded planning and diagnostic feedback.
- Structured and Constraint-Aware Generation: Origami is an executable long-horizon process combining discrete topology changes with continuous kinematic transformations under strict physical validity constraints.
- Structured and Constraint-Aware Generation: Unlike one-shot geometry generation, early violations such as self-intersections or non-flat-foldable steps can compound and invalidate later folding.
- Structured and Constraint-Aware Generation: Its CP-grounded programs provide diagnostic feedback that attributes fold failures, supporting planning and recovery on out-of-distribution crease patterns.
- World Models: Forward kinematic simulators calculate geometric consequences of given folds but do not plan sequences or reason about high-level semantic goals.
- Structured and Constraint-Aware Generation: Geometry-centric systems such as TreeMaker and Origamizer mathematically guarantee folding a target mesh from one sheet but handle ambiguous semantic descriptions poorly.
3. Method
Learn2Fold represents origami as a canonicalized crease-pattern graph with dynamic folding states, then combines language-conditioned action proposals with hard verification and learned world-model lookahead. Its method also introduces the OrigamiCode dataset of structured folding programs and physically consistent trajectories for training and evaluation.
- State Representation and Canonicalization: Canonicalization reindexes vertices and edges deterministically and augments rotations and reflections so structurally identical crease patterns share an index space.The transformation is designed to provide permutation invariance and reduce orientation bias.
- Framework: Learn2Fold formulates origami folding as conditional program induction over a graph-structured manifold, generating valid folding operations from semantic goals and current state.Each instance is represented by static topology G and dynamic state s_t, and the policy generates structured actions conditioned on context.
- Policy Learning: The policy unifies operations, canonicalized graph elements, and quantized geometric parameters into one token vocabulary for autoregressive action generation.This representation captures joint dependencies between topological intent and geometric specifications.
- Inference via Graph-Guided MPC: At inference, candidate actions are sampled on the crease-pattern graph, filtered by a deterministic Level-0 constraint kernel, and ranked using learned world-model rollouts.The world model predicts residual state updates and per-edge violation likelihoods, while action selection combines proposal likelihood, goal progress, and feasibility.
- Inference via Graph-Guided MPC: When no valid candidate remains or the best score falls below τ, Learn2Fold derives negative constraints from predicted violations and resamples candidates.The constraint is formed from high-scoring affected edges in the predicted violation mask.
- Dataset Construction: OrigamiCode contains 25 object classes represented by parameterized crease-pattern graphs and structured folding specifications, with 5,760 process sequences and 75,000 trajectories.The dataset records evolving mesh geometry, crease states, and fold parameters to support fold prediction, sequence generation, and manipulation tasks.
4. Experiments
Learn2Fold is evaluated on held-out origami categories using step-level accuracy, trajectory-level success, and qualitative folding behavior. It outperforms baselines quantitatively and maintains stronger long-horizon consistency, while ablations show complementary roles for proposal, world-model lookahead, and constraint filtering.
- Experiment Setup: At each inference step, the language model proposes N = 8 actions, invalid candidates are filtered, and the world model scores survivors through short-horizon rollouts.
- Experiment Setup: The evaluation uses 25 origami categories, with an 80% training split and a 20% held-out evaluation split.
- Learn2Fold achieves Precisionµ/Recallµ/F1µ of 0.766/0.711/0.739, exceeding GPT-5.1’s F1µ of 0.266 by 47.3 absolute points.
- Qualitative Study: Learn2Fold produces coherent, fine-grained trajectories, whereas baselines commonly suffer invalid actions, premature termination, or long-horizon recovery failures.
- Ablation: The ablation identifies complementary roles for the LLM proposer, world model, and Level0Sim, whose combination supports robust long-horizon folding.
- Ablation: Adding the world model raises IID Traj SR from 22.2% to 25.0% and reduces IID final goal distance from 0.796 to 0.759, while Level0Sim further improves full-system performance.
5. Conclusion
The conclusion presents Learn2Fold as a neuro-symbolic framework for physically valid origami process generation. It frames origami as a testbed for spatial reasoning over coupled discrete topology, continuous geometry, irreversible constraints, and long-horizon dependencies.
- Learn2Fold formulates origami folding as constraint-aware program induction over a crease-pattern graph.
- The framework unifies semantic reasoning with rigorous geometric constraint enforcement for executable action sequences.
- Origami exposes spatial-reasoning challenges involving discrete topological decisions coupled with continuous geometry and long-horizon dependency.
A. More Model and Implementation Details
Learn2Fold uses a canonicalized crease-pattern graph together with dynamic folding state as a shared representation across data generation, training, and inference-time planning.
- Each origami instance combines a canonicalized crease-pattern graph with its dynamic folding state.
- A unified graph-state interface is shared across data generation, model training, and inference-time planning.
B. Evaluation Protocol
The evaluation protocol measures both structured action prediction and long-horizon execution on held-out origami categories. Common representations and repeated runs support comparable assessment across methods and ablation settings.
- Benchmark: The held-out benchmark spans 25 origami categories across simple, intermediate, and complex difficulty tiers.
- Benchmark: The final test suite contains 3,840 text prompts, with 1,150 validation cases and two independent runs per prompt for each method.
- Baselines: Learn2Fold is compared with prompted foundation models and a second baseline class under a common structured-output interface when possible.
- Metrics: Precision, Recall, and F1 measure structured action-token accuracy, while Cat-SR and Edge-IoU measure trajectory success and structural alignment.
- Inference and Ablation: Inference uses candidate proposal, Level-0 simulator filtering, world-model lookahead, and autoregressive rollout until termination or failure.
- Reproducibility: Fixed random seeds and a shared canonicalized representation and action schema reduce representation mismatch and support common evaluation.