Abstract

We describe a two-phase framing for building modular reasoning pipelines: Functional Atomic Decomposition (FAD), which factors a task into small, single-purpose functions, and Functional Atomic Recomposition (FAR), which recombines those functions into higher-order compositions selected at runtime for the specific input. FAD and FAR restate the defining moves of function-level programming [1], the modularity argument for higher-order functions and lazy evaluation [2], and the abstraction and parameterization concepts formalized in the foundations of programming languages [3]. The contribution is to name the decompose→recompose cycle as an explicit methodology for reasoning pipelines, to situate it against modular adaptation in modern machine learning — adapter layers [4] and low-rank adaptation [5] — and against the failure mode that motivates modularity in the first place: catastrophic interference under sequential learning [6, 7]. The framing isolates one sharp question — whether the relevant atoms for an input can be selected accurately and cheaply enough for context-conditioned composition to beat a fixed monolithic procedure — and makes that selection step a first-class, measurable component rather than an assumption buried in a pipeline.

1. Introduction

Building a reasoning system means (a) breaking a task into small reusable pieces and (b) recombining those pieces into a solution appropriate to the specific input. This is the oldest idea in structured and functional programming, applied to reasoning pipelines. Backus's Turing Award lecture argued for programming as the algebraic composition of functions rather than step-by-step state mutation [1]; Hughes showed that higher-order functions and lazy evaluation are precisely the "glue" that makes such decomposition pay off in modularity [2]; and the vocabulary of abstraction, parameterization, and first-class functions was set out decades earlier [3].

FAD names the decomposition phase and FAR names the recomposition phase. The move that matters is running composition at runtime, conditioned on the input, rather than executing one fixed pipeline for every input. That is the design under study, and the step that decides whether it pays off — selecting the relevant atoms per input — is named explicitly here rather than folded into a monolithic procedure.

2. Related Work

Functional composition. The decompose→recompose cycle is the standard vocabulary of functional programming: composition of pure functions [1], higher-order functions as the mechanism of modularity [2], and the language-theoretic concepts of abstraction and first-class functions [3]. FAD and FAR apply that composition to reasoning-pipeline design.

Modular adaptation in machine learning. The intuition that a large model should be specialized by adding small, composable, reusable modules rather than by rewriting the whole system has direct analogues in parameter-efficient transfer learning: adapter layers [4] and low-rank adaptation [5] both insert small reusable units into a frozen backbone. FAR's recomposition phase is aligned with this literature, operating at the level of orchestrated functions rather than weight-space updates.

Why modularity pays. Monolithic sequential adaptation forgets: catastrophic interference in connectionist networks [6] is mitigated, not solved, by regularization such as Elastic Weight Consolidation [7]. A pipeline assembled from independently maintained atomic functions does not overwrite one capability while acquiring another — the structural reason to build the composition out of atoms rather than one entangled procedure.

3. The FAD → FAR Methodology

FAD (decomposition). Factor a task into atomic functions: single-purpose, independently testable, and reusable across tasks. This preparatory phase yields a library of primitives.

FAR (recomposition). Given an input, select and compose the relevant atomic functions into a higher-order pipeline for that input, rather than executing a fixed pipeline for every input. The selection step is what makes the composition context-conditioned, and it is the component that carries the method's leverage.

The economics are direct: if the relevant atoms for an input are identified cheaply, composing only those atoms is more economical than running a fixed monolithic procedure — fewer functions activated per input is less work per input. The variable that decides the outcome is the selection step's accuracy and overhead. FAD/FAR makes that step a named, first-class, swappable component, which is what turns "modular reasoning is more economical" from a slogan into a measurable claim.

4. Where the Benefit Is Decided

The fixed monolithic reasoning procedure is the baseline a FAR-composed pipeline is positioned against: the same task, run as one entangled pass, is the reference point for both cost and quality. The composed pipeline wins when context-conditioned selection activates a small, sufficient subset of atoms and the selection overhead stays below the work it saves. That is a single, sharp condition — accurate, cheap atom selection — and it is where the architecture meets a number. FAD/FAR's factoring is what exposes that condition as one component to instrument rather than a property diffused across an opaque pipeline.

5. Modular Composition and Cognition

Reasoning built from reusable sub-skills, recombined per problem, is the structural parallel that motivates the framing: capability is maintained as independent atoms and assembled on demand, which is the same property that lets modular adaptation add skills without overwriting old ones [4, 5] and that sidesteps the interference monolithic learning suffers [6, 7]. FAD/FAR carries that modular-reuse structure into the design of reasoning pipelines.

Evidence & Scope

FAD → FAR is a design methodology with one isolated, testable question. It applies the established composition tradition [1, 2, 3] to reasoning pipelines and makes runtime, input-conditioned atom selection a first-class component. The claim that composition beats a fixed monolithic procedure holds exactly when atom selection is accurate and cheap enough that the work saved exceeds the selection overhead — an empirical condition, and the named variable that decides the result. The baseline is the monolithic pipeline; the selection step is what settles the outcome.

References

  1. John Backus (1978). Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs. Communications of the ACM. [1977 ACM Turing Award Lecture]
  2. John Hughes (1989). Why Functional Programming Matters. The Computer Journal.
  3. Christopher Strachey (2000). Fundamental Concepts in Programming Languages. Higher-Order and Symbolic Computation. [Reprint of 1967 lecture notes]
  4. Neil Houlsby et al. (2019). Parameter-Efficient Transfer Learning for NLP. Proceedings of the 36th International Conference on Machine Learning (ICML). arXiv:1902.00751.
  5. Edward J. Hu et al. (2022). LoRA: Low-Rank Adaptation of Large Language Models. International Conference on Learning Representations (ICLR). arXiv:2106.09685.
  6. Michael McCloskey & Neal J. Cohen (1989). Catastrophic Interference in Connectionist Networks: The Sequential Learning Problem. Psychology of Learning and Motivation.
  7. James Kirkpatrick et al. (2017). Overcoming Catastrophic Forgetting in Neural Networks. Proceedings of the National Academy of Sciences (PNAS). arXiv:1612.00796. [Elastic Weight Consolidation (EWC)]