How do progressive abstraction chains differ from branching reasoning topologies?

This explores the difference between reasoning that moves *vertically* — up and down levels of abstraction — and reasoning that moves *horizontally*, splitting into branches and recombining them. They're easy to conflate because both are dressed up as "structured reasoning," but the corpus treats them as solving different problems.

The cleanest map of the branching side comes from the topology taxonomy Can reasoning topologies be formally classified as graph types?, which shows that chain-of-thought, tree-of-thought, and graph-of-thought aren't loose metaphors — they're literally a path graph, a tree, and a directed graph. The structural payoff is in the connections: a graph allows a node to have more than one parent (in-degree > 1), which lets it merge separately-explored sub-results in a way a tree simply can't express. So "branching topology" is about the *shape of the search* — how many paths you open and whether they can rejoin. The recursive-subtask-tree work Can recursive subtask trees overcome context window limits? and the algorithmic-control approach Can algorithms control LLM reasoning better than LLMs alone? push this further: they decompose a hard task into a tree of sub-tasks and manage which branch gets attention, even pruning memory so the structure can run beyond the context window.

Progressive abstraction chains do something orthogonal. In the RLAD work Can abstractions guide exploration better than depth alone?, the model first generates *abstractions* — reusable strategies — and only then generates solutions under them. The surprising result is that this produces breadth where a plain chain produces depth: spending test-time compute on diverse abstractions beats sampling many parallel solutions. So abstraction isn't a third branch; it's a layer *above* the solution space that decides which regions are worth branching into at all. Partial symbolic abstraction Why does partial formalization outperform full symbolic logic? makes the same move at a smaller grain — enriching natural language with selective symbolic structure rather than fully formalizing — and the token-importance work Which tokens in reasoning chains actually matter most? shows models already rank their own steps by abstraction level, preserving symbolic computation while discarding meta-chatter.

The deeper reason the distinction matters is *failure modes*. Branching structures fail by wandering — the "tourist" problem Why do reasoning models abandon promising solution paths? where models abandon promising paths, and the underthinking problem Do reasoning models switch between ideas too frequently? where a decoding penalty on thought-switching alone recovers accuracy. More branches means more opportunities to flit. Abstraction chains are proposed as the antidote: a layer of strategy enforces commitment to a direction before the search fans out, which is precisely why abstraction-guided breadth outperforms unguided depth Can abstractions guide exploration better than depth alone?.

The thing you might not have expected to want to know: making reasoning *more branchy* isn't reliably better. The constraint-satisfaction ceiling Can reasoning models actually sustain long-chain reflection? shows frontier models stalling at ~20% on problems that need genuine backtracking through a search tree, and inductive-rule work Why do reasoning models fail at exception-based rule inference? shows reasoning models actually *underperform* simpler ones when extra structure breeds overgeneralization and hallucinated constraints. Topology gives you expressive power; abstraction gives you the discipline to use it — and the corpus suggests the second is the scarcer ingredient.