Structure-Oriented Abstraction

• Structure-oriented abstraction is a family of practices that organizes and refines systems by preserving relationships among components using layering, modularity, and interface design.
• It leverages methods from programming education, design theory, and digital infrastructures to simplify and manage complex systems through explicit structural operations.
• Evaluations range from computational complexity analysis to practical implementations in AI, engineering, and code structuring, underscoring its impact across diverse domains.

Searching arXiv for relevant papers on structure-oriented abstraction and adjacent formulations. {"query":"structure-oriented abstraction abstraction engineering code structuring FBS refinement abstraction arXiv", "max_results": 10} Searching for the specific code-structuring framework and foundational abstraction papers referenced in the source material. {"query":"(Haldeman et al., 5 Dec 2025) Systematically Thinking about the Complexity of Code Structuring Exercises at Introductory Level", "max_results": 5} {"query":"(Rieder, 25 Aug 2025) What is digital about abstraction (Bencomo et al., 2024) Abstraction Engineering (Diertens, 2013) Refinement in the Function-Behaviour-Structure Framework", "max_results": 10} Structure-oriented abstraction denotes a family of abstraction practices in which the primary object of simplification, refinement, or generalization is a structure: a procedure boundary in code, a layered software stack, a design architecture, a logical theory, a type, a graph, a heap region, or a latent transition manifold. In introductory programming it appears in “code structuring tasks, where students must identify and separate meaningful abstractions within existing, unstructured code” (Haldeman et al., 5 Dec 2025). In design theory it is made explicit by refinement frameworks in which “the structure $S'$ in the design process FBS' is a refinement of the structure $S$” (Diertens, 2013). In broader computing it is expressed through layering, modularity, interfaces, and information hiding that organize both technical artifacts and socio-technical systems (Rieder, 25 Aug 2025). Taken together, these formulations suggest a general notion: abstraction is structure-oriented when it preserves, compresses, or reorganizes relations among components, levels, or interactions, rather than merely suppressing detail.

1. Conceptual scope

Across the literature, structure-oriented abstraction is not a single formalism but a recurrent stance toward representation. In “What is digital about abstraction?” abstraction is described as the set of practices by which functionality, data, and operations are organized into layered, modular, and interface-defined structures, including operating systems, protocol stacks, APIs, platforms, and cloud services (Rieder, 25 Aug 2025). In “Abstraction Engineering,” abstractions are treated as first-class engineered artifacts spanning deductive models, learned models, controllers, APIs, and pipelines, with explicit concern for their construction, use, assurance, and evolution (Bencomo et al., 2024). This suggests a cross-domain family resemblance: abstraction is structure-oriented when the representation itself carries an explicit architecture.

Setting	Structural object	Typical operation
Procedural programming	Functions, parameters, procedure boundaries (Haldeman et al., 5 Dec 2025)	Extract coherent sub-tasks from monolithic code
Design theory	$F, Be, S, Bs, D$ across abstraction levels (Diertens, 2013)	Refine $S$ into $S'$
Digital infrastructures	Layers, modules, APIs, abstract machines (Rieder, 25 Aug 2025)	Hide implementation behind interfaces
Logic-based abstraction	Vocabularies, theories, bridges, bounds (Szalas, 30 Oct 2025)	Compute $wsc$ and $snc$ over $\Sigma_A$
Type theory	Behavioral and algorithmic phases (Grodin et al., 27 Feb 2025)	Separate public behavior from private implementation
Data extraction	Attribute schemas and JSON event structures (Wong et al., 2 Feb 2025)	Normalize unstructured text into structured fields

A recurrent implication is that abstraction is not merely “less detail.” It is an organized representation with explicit roles, interfaces, and constraints. That implication is stated directly in “Abstraction Engineering,” which generalizes modeling beyond classical diagrams to learned models, feature spaces, state estimators, controllers, and API layers (Bencomo et al., 2024).

2. Structural primitives and recurrent mechanisms

The most persistent primitives are layering, modularity, interfaces, and information hiding. In digital systems, “higher level layers on top of the lower level” form strata in which each level exposes an interface and hides implementation details below; operating systems, protocol stacks, compilers, databases, and cloud offerings are presented as paradigmatic realizations of this pattern (Rieder, 25 Aug 2025). The same source emphasizes that modularity divides software into components “such that each component can be designed independently of the others,” while information hiding structures both code and labor.

In software pedagogy, the structural unit is the procedure. “Systematically Thinking about the Complexity of Code Structuring Exercises at Introductory Level” treats decomposition and abstraction in procedural programming as bottom-up work on existing code: students identify coherent sub-tasks, extract them into functions or methods, introduce parameters, and simplify the top-level driver (Haldeman et al., 5 Dec 2025). The guiding quality criterion is functional cohesion: good procedural abstractions are routines that “do one thing.” The paper therefore shifts emphasis from syntax toward code comprehension, recognition of algorithmic patterns, and reasoning about data dependencies and procedure boundaries.

In design theory, the structural primitive is the design description $S$. The R-FBS framework adds explicit refinement links between abstraction levels: functionality refinement $\{D,F\}\rightarrow F'$, expected-behaviour refinement $S$0, structure refinement $S$1, and documentation refinement $S$2 (Diertens, 2013). What distinguishes this account is that structure is not re-synthesized from scratch at each level; the lower-level structure must remain consistent with the higher-level one.

A different structural critique appears in conceptual modeling. “Classes in Object-Oriented Modeling (UML): Further Understanding and Abstraction” argues that UML class diagrams are oriented toward logical design, because they force facts into classes, attributes, navigability constraints, and encapsulated operations too early (Al-Fedaghi, 2021). The proposed Thinging Machine model interlaces structure and actionality: classes, subclasses, and attributes are all “thimacs” or subthimacs, and the class description becomes a shorthand for a richer semantic construct.

3. Formalizations of structure-oriented abstraction

Several papers give explicitly formal accounts. In “Bridge and Bound: A Logic-Based Framework for Abstracting,” an abstraction begins with a source theory $S$3, an abstract vocabulary $S$4, and a bridging theory $S$5, and produces an approximate abstraction $S$6 over $S$7 (Szalas, 30 Oct 2025). The lower bound preserves sufficient conditions, the upper bound preserves necessary conditions, and the tightest abstraction is

$S$8

The same framework extends to layered abstractions and proves a compositionality result: layered abstraction is equivalent to a one-shot abstraction with the conjunction of the bridging theories. Its computational limits are also explicit: in the propositional case, checking whether $S$9 is an abstraction is coNP-complete, while first-order variants are semi-decidable.

“Abstraction Functions as Types” internalizes abstraction into dependent type theory through a phase distinction between public behavior and private algorithmic content (Grodin et al., 27 Feb 2025). The behavioral modality is

$F, Be, S, Bs, D$0

and the fracture theorem states that every type is equivalent to a triple consisting of a behavioral type, an algorithmic type, and an abstraction function: $F, Be, S, Bs, D$1 The modularity corollary formalizes representation independence: replacing the private algorithmic part does not affect client-visible behavior.

“Towards a Mathematical Theory of Abstraction” gives a query-oriented account. An abstraction is a low-dimensional summary $F, Be, S, Bs, D$2 together with a maximum-entropy completion $F, Be, S, Bs, D$3, evaluated by the leakiness

$F, Be, S, Bs, D$4

for a query $F, Be, S, Bs, D$5, and by averages over a query set $F, Be, S, Bs, D$6 (Millidge, 2021). In the dynamical setting, the same idea is generalized via maximum calibre over trajectories. This makes abstraction structure-oriented in a precise sense: the summary is judged by which relations, invariants, or query answers it preserves.

Control-theoretic abstraction gives a further variant. “Sparsity-Sensitive Finite Abstraction” exploits dependency-graph structure to factor symbolic abstractions coordinate-wise, reducing complexity from $F, Be, S, Bs, D$7 to $F, Be, S, Bs, D$8 when the sparsity parameter $F, Be, S, Bs, D$9 is small (Gruber et al., 2017). “Smart abstraction based on iterative cover and non-uniform cells” uses non-uniform ellipsoidal cells and local optimal control to build a goal-specific abstraction for reach-avoid tasks, so that cell shape and volume are optimized jointly with local controllers (Calbert et al., 2024). In both cases, the abstract state space is shaped by structural properties of the dynamics rather than by a fixed uniform partition.

4. Learning and representation

In learned systems, structure-oriented abstraction often appears as an explicit architectural bottleneck. “Abstraction Learning” introduces ONE, which partitions a network into a task-agnostic cognitive part, an abstraction locked layer with pre-allocated abstraction neurons, and non-overlapping task-specific decision parts (Deng et al., 2018). Abstraction learning is formulated as constrained optimization with variety, simplicity, and effectiveness constraints, including sparse activations at the cognitive and abstraction layers and entropy-based selection of abstraction neurons. On MNIST, the reported properties are low energy consumption, knowledge sharing, and lifelong learning.

“Structure Abstraction and Generalization in a Hippocampal-Entorhinal Inspired World Model” separates relational structure from episodic content by assigning MEC-like latents to structural transitions and HPC-like latents to integrated scenes (Zhang et al., 15 May 2026). The inverse model extracts latent transitions from MEC differences,

$S$0

while the forward model performs path integration in latent space. On primitive transformation benchmarks, transition decoding from $S$1 reaches $S$2, exceeding decoding from $S$3 and $S$4. The model is then used for structural reuse across objects and scenes.

In text-rich graphs, “Odin: Oriented Dual-module Integration for Text-rich Network Representation Learning” aligns structural abstraction with Transformer depth (Hong et al., 26 Nov 2025). TG layers inject graph structure through learnable aggregation of global [CLS] representations; TS layers maintain lighter structural conditioning. The paper’s central claim is that low-, mid-, and high-level structural abstraction should be aligned with the semantic hierarchy of the Transformer rather than with hop-by-hop diffusion, and it proves that Odin’s expressive power strictly contains that of both pure Transformers and GNNs.

Evaluation itself can be structure-oriented. “Abstraction Alignment” externalizes human knowledge as an abstraction graph and compares it to model behavior using metrics such as accuracy abstraction alignment $S$5, uncertainty abstraction alignment $S$6, subgraph preference $S$7, and concept confusion $S$8 (Boggust et al., 2024). This moves interpretability from isolated concepts to the structure of conceptual relationships.

5. Representative domains and applications

In programming education, structure-oriented abstraction is operationalized as code structuring. The framework of “Systematically Thinking about the Complexity of Code Structuring Exercises at Introductory Level” classifies tasks by three dimensions—Repetition, Code Pattern Composition, and Data Dependency—each with four ordinal levels, and supports practical use with example tasks and an interactive tool (Haldeman et al., 5 Dec 2025). The focus is explicitly procedural and bottom-up: the program is already functionally correct but poorly structured, and the task is to identify and extract meaningful abstractions.

In software and systems engineering, structure-oriented abstraction functions as an organizing discipline. “Abstraction Engineering” calls for process models and tool chains, including well-defined APIs, to support the rigorous development, use, and assurance of abstractions across formal modeling and AI/ML (Bencomo et al., 2024). This places architectural views, learned models, and domain-specific abstractions within one engineered lifecycle.

In heap analysis, the structural object is the heap component. “Recognition of Logically Related Regions Based Heap Abstraction” defines concrete and abstract heaps, identifies logically related regions in singly linked lists, binary trees, cycles, and DAGs, and produces compact normal forms by merging ordinary nodes while preserving special nodes and component layout (El-Zawawy, 2012). The stated applications include static deallocation, pool allocation, region-based garbage collection, and object co-location.

In spatial analytics, structure-oriented abstraction converts road topology and trajectories into a hierarchical graph representation. “Revealing intra-urban spatial structure through an exploratory analysis by combining road network abstraction model and taxi trajectory data” represents the Wuhan road network as a weighted directed graph $S$9, learns node relatedness from map-matched taxi trajectories via Word2Vec, and applies Infomap to recover three levels of spatial structure (Hu et al., 2022). The result is a multilevel decomposition from macro-scale “Three Towns” structure to finer functional communities.

In medical information extraction, “Universal Abstraction: Harnessing Frontier Models to Structure Real-World Data at Scale” uses a universal prompt template to extract fifteen oncology attributes as JSON-structured events from longitudinal clinical text, with attribute definitions, descriptor definitions, guideline summaries, and ontology-normalized outputs (Wong et al., 2 Feb 2025). Compared with supervised and heuristic baselines, UMA with GPT-4o achieves on average an absolute 2-point F1/accuracy improvement for both short-context and long-context attribute abstraction, and for pathologic T staging it outperforms the supervised model by 20 points in accuracy.

In image generation, “Abstraction in Style” separates structural abstraction from visual stylization by first deriving a Hidden Backbone and then an abstraction proxy, before rendering the final stylized output in a second stage (Lu et al., 31 Mar 2026). Backbone $S'$0 Proxy is learned by A-VAT; Proxy $S'$1 Output by S-VAT. The method thereby treats “abstraction logic” as transferable structure rather than as a by-product of texture transfer.

6. Significance, limits, and recurring controversies

A recurrent theoretical distinction is between structure-oriented, function-oriented, and behaviour-oriented abstraction. The R-FBS literature is explicit that its distinctive feature is the treatment of structure as the invariant spine across levels, with function and behavior refined relative to that spine rather than used to re-synthesize structure from scratch (Diertens, 2013). This distinction matters because different engineering traditions privilege different invariants.

The broader significance of structure-oriented abstraction is not merely technical. In digital infrastructures, abstraction organizes labor, governance, and dependence: interfaces and layers define who controls which capabilities, who can participate, and how ecosystems are coordinated (Rieder, 25 Aug 2025). The same chapter argues that abstraction is a locus of power because lower layers shape what can occur above them, while platform and cloud abstractions embed switching costs and governance mechanisms into technical interfaces.

Its limits are equally recurrent. Logic-based formulations can become computationally expensive, since tightest abstractions depend on second-order quantifier elimination and exactness checking is coNP-complete in the propositional case and semi-decidable in the first-order case (Szalas, 30 Oct 2025). Learned structural abstractions can be sensitive to architecture and domain: ONE is demonstrated only on MNIST and depends on growth and extinction hyperparameters (Deng et al., 2018), while the HPC-MEC world model reports autoregressive error accumulation and weaker generalization in some highly artificial environments (Zhang et al., 15 May 2026). Evaluation frameworks can also inherit limitations from the human structures they use: “Abstraction Alignment” shows that low alignment may reveal not only model failure but also deficiencies in the human abstraction itself, as in ICD-9 coding practice and revisions reflected later in ICD-10 (Boggust et al., 2024).

A plausible synthesis is that structure-oriented abstraction is most powerful when three conditions hold simultaneously: the structural object is explicit, the abstraction boundary is operational, and the preserved relations are tied to a concrete purpose such as reasoning, control, generalization, or normalization. Where those conditions fail, abstraction either collapses into vague simplification or becomes an expensive formal artifact with limited practical leverage. Where they hold, structure-oriented abstraction functions as a general strategy for making complex systems analyzable, controllable, and reusable across levels.