Exploring Depth Generalization in Large Language Models for Solving Recursive Logic Tasks

TL;DR

This paper investigates the limitations of large language models in handling recursive reasoning tasks with increasing depth, identifies architectural constraints, and proposes a novel pipeline to improve depth generalization across multiple logical domains.

Contribution

The study reveals the depth generalization challenge in transformer models and introduces a looped locate-and-replace pipeline with specialized models to enhance recursive problem solving.

Findings

Transformer models struggle with deeper recursion than seen during training.

The proposed pipeline improves out-of-distribution depth generalization.

Method is effective across Boolean algebra, recursive arithmetic, and propositional logic.

Abstract

Large language models have demonstrated remarkable capabilities across many tasks, yet face significant challenges when dealing with recursive reasoning problems, those requiring the resolution of nested hierarchical structures. While prior research has extensively studied length generalization (a model's ability to handle longer sequences than seen during training), we investigate a distinct and underexplored limitation: depth generalization. Here, depth refers to the number of nested levels in a hierarchical problem, such as the layers of parentheses in a mathematical expression or the nesting of logical clauses in a Boolean formula. Our work reveals that standard transformer architectures struggle with problems involving deeper recursion than encountered during training, even when they perform well on longer but non-nested sequences. This limitation stems from their inability to maintain stack-like behavior, the capacity to track and resolve multiple levels of nested dependencies. Through systematic analysis, we demonstrate how this architectural constraint leads to rapid performance decay as the depth of the recursion increases. To address this challenge, we develop a novel looped locate-and-replace pipeline that decomposes recursive problems into manageable subcomponents. The approach employs two specialized models: a locator that identifies solvable subexpressions and a replacer that evaluates these components while preserving the overall structure. We evaluated this method in three carefully designed domains: Boolean algebra, recursive arithmetic, and propositional logic, each with a controllable depth of recursion. We show that our method effectively alleviates the performance decay when tested on out-of-distribution recursion depth.