Abstraction-Concretization Framework Overview

• Abstraction-Concretization Framework is a method that transforms detailed representations into abstract models by selectively discarding non-essential details while preserving critical properties.
• It employs formal mappings, such as abstraction (α) and concretization (γ) functions, to ensure sound transitions from abstract specifications to executable or analyzable forms.
• The framework supports layered, hierarchical organization, enabling progressive refinement from high-level specifications to concrete realizations in domains like controller synthesis and GUI testing.

An abstraction-concretization framework is a structured method for transforming a source representation into an abstract representation that discards certain details while retaining desirable features, and for relating that abstract representation back to an executable, analyzable, or otherwise concrete realization. In the research literature, this pattern appears in several technically distinct but conceptually related forms: layered computational models in which concrete sequential execution is treated as an implementation of more abstract concurrent models; semantic frameworks based on abstraction and concretization maps such as $\alpha$ and $\gamma$; and domain pipelines that begin with high-level specifications and end in numeric scenes, controllers, test cases, or code (Diertens, 2012, Holtzen et al., 2017, Babikian et al., 2023).

1. Conceptual scope and defining features

A recurrent claim across the literature is that abstraction is not merely the production of a simpler description. In logic-based accounts, abstraction is the transformation of a source representation into an abstract representation that discards certain details while retaining desirable features, and in approximate settings the result may be bounded from below and above rather than given as a single exact theory (Szalas, 30 Oct 2025). In interaction-oriented work, abstraction is treated as a schema of information, while representation is the concrete instantiation of such an abstraction in a specific medium, notation, or format that renders the information perceptible and operable (Min et al., 11 May 2026).

In execution-oriented frameworks, the distinction between abstraction and concretization is expressed operationally rather than terminologically. The computational-model hierarchy from function execution to object execution proceeds by abstracting from how function calls are implemented, abstracting from shared-memory communication, abstracting from how methods are scheduled, and then relating the resulting model to object-orientation fundamentals (Diertens, 2012). In that setting, sequential execution is not the defining essence of functions or objects, but a possible implementation of a more abstract concurrent model.

This suggests that an abstraction-concretization framework is best understood as a relation between levels of description rather than as a single formalism. Some frameworks move upward from concrete executions to abstract models; others move downward from abstract specifications to concrete realizations; several do both. What they share is an explicit account of which details are hidden, which properties are preserved, and how the resulting abstract artifact is connected back to an operational substrate.

2. Formal relations, mappings, and guarantees

In program abstraction, the classical relation between concrete and abstract states is expressed through an abstraction function $\alpha$ and a concretization function $\gamma$. For non-deterministic abstractions, the induced concrete semantics is $C_A(z)=\gamma(A(\alpha(z)))$, and soundness requires that every concrete execution be contained in the abstract program’s concretization. The probabilistic generalization replaces set-valued concretization by a conditional distribution ${}_\gamma(z\mid a)$ and abstract semantics by a probabilistic transition kernel ${}_A(a_o\mid a_i)$, yielding the induced concrete semantics

$${}(z_o\mid z_i)=\sum_{a_o\in D}{}_\gamma(z_o\mid a_o)\,{}_A(a_o\mid \alpha(z_i)).$$

The corresponding soundness notion is support-based: every concrete execution must have nonzero probability in the induced concrete semantics (Holtzen et al., 2017).

A categorical reconstruction of abstract interpretation recasts semantics as oplax functors into Pos, while concretization and abstraction between interpretations are expressed as lax and oplax natural transformations. If $C:L\to\mathrm{Pos}$ is an interpretation and each object carries a Galois connection between an abstract domain and the concrete one, the induced abstract interpretation is given pointwise by

$C^G(f)=\alpha_b\circ C(f)\circ \gamma_a.$

This preserves the standard “best abstract transformer” construction, but the resulting semantics is generally oplax rather than strictly functorial (Katsumata et al., 2023).

Logic-based frameworks extend the preservation story beyond consequences. In the bridge-and-bound formulation, an approximate abstraction is a pair $\gamma$0 over an abstract vocabulary, where $\gamma$1 preserves sufficient conditions and $\gamma$2 preserves necessary conditions relative to a bridging theory $\gamma$3. The tightest abstraction is uniquely determined by

$\gamma$4

and an abstraction is exact when $\gamma$5 (Szalas, 30 Oct 2025).

Controller-synthesis work gives concretization a more architectural meaning. For a concrete transition system $\gamma$6 and an abstraction $\gamma$7 related by a discretization relation $\gamma$8, the memoryless concretization relation (MCR) characterizes precisely when a controller synthesized on the abstraction can be concretized by a controller that depends only on the current concrete state. The paper proves both sufficiency and necessity for this memoryless concretization property, thereby isolating the exact relation under which abstract control can be realized without tracking the abstract trajectory online (Calbert et al., 2024).

3. Layered construction and hierarchical organization

Many frameworks are explicitly multi-layered. In the execution model leading from functions to object-orientation, the development is presented as a progression from a sequential machine model to a sequential computational model, then to a concurrent computational model, and finally to a concurrent machine model. The decisive abstraction step is the removal of scheduling detail: once function-call implementation and scheduling are abstracted away, concurrent execution of functions becomes admissible, and sequential execution becomes one possible realization of that abstract model (Diertens, 2012).

Autonomous-vehicle scene concretization makes this layering explicit in a specification pipeline. The process separates a high-level functional scene specification, a numeric logical scene, and a concrete scene executable in a simulator. The abstract layer uses a 4-valued partial-model language for functional scene specifications, with relations interpreted in $\gamma$9 and validity rules that support static pruning of impossible specifications. The mapping $\alpha$0 translates abstract relations into numeric constraints over oriented rectangles on a road map, after which metaheuristic search produces exact vehicle poses (Babikian et al., 2023).

Hierarchical reinforcement learning introduces a different but related pattern. The skill-symbol loop alternates a skill-acquisition phase with a representation-acquisition phase, thereby constructing a sequence of increasingly abstract MDPs. At each level, skills determine the abstract state representation needed for planning with them; the resulting abstract MDP can then serve as the substrate for acquiring still higher-level skills. Concretization appears as downward refinement: a policy at level $\alpha$1 is also a policy at every level below it, including the base MDP (Konidaris, 2015).

Software analytics frameworks use operator stacks rather than state-space hierarchies, but the organizational principle is similar. A multi-layered abstraction mechanism is built from basic operators such as filter, select, join, sort, and count; Level 1 operators such as FindMax = filter + sort + select; and Level 2 operators for tasks such as issue-revision linking, change distilling, and code smell detection. Here abstraction packages recurring low-level repository operations into reusable semantic units, while concretization lowers an analytics question into a sequence of repository operations across heterogeneous sources (Wijesiriwardana et al., 26 Sep 2025).

4. Computational and engineering instantiations

In computational models of programming, the framework serves as a bridge from function execution to object execution. The central claim is that functions, methods, objects, and variables can all be treated as objects at some level of abstraction; what changes is the computational model used to execute them. Once scheduling of methods is separated from scheduling of objects, each object can schedule its own methods, a method call becomes a request to the object, and object-level concurrency becomes available while remaining compliant with the paper’s account of object-orientation fundamentals—state, behavior, identity, and interaction by message passing (Diertens, 2012).

In probabilistic program analysis, abstraction is itself a probabilistic program. Predicate abstractions are lifted from non-deterministic choice to Bernoulli choice by replacing classical non-deterministic branches with expressions such as flip(\theta), and by giving assignments probabilistic predicate updates. The framework thereby turns abstraction into an inference-capable model while preserving the support-based sound over-approximation relation to the concrete program (Holtzen et al., 2017).

Controller synthesis uses abstraction to replace a concrete plant by a finite or simpler transition system and concretization to refine an abstract controller back to the plant. The significance of MCR is greatest when the quantizer is non-deterministic, as in overlapping covers rather than partitions. In such cases, a concrete state may belong to multiple abstract cells, and the concretization step must work no matter which abstract cell the state is viewed through. The paper also shows that any ASR abstraction can be completed to satisfy MCR by adding transitions, at the expense of increasing non-determinism in the abstraction (Calbert et al., 2024).

GUI test migration employs the same vocabulary in a distinctly software-engineering sense. The abstraction-concretization paradigm first abstracts the test logic for the target functionality from multiple source test cases, then concretizes that logic into a target-app GUI test case with events and assertions. MACdroid implements this through an Abstractor that extracts and summarizes structured test steps and a Concretizer that matches or completes those steps against the target app state using an LLM. The empirical evaluation reports success on 64% of target functionalities on FrUITeR and 75% on Lin, with 100% executable-rate in both settings (Zhang et al., 2024).

Traffic-scene concretization is a further engineering instance in which abstraction is explicitly specification-level and concretization is geometry-level. The framework maps qualitative relations such as left, ahead, medDist, canSee, noColl, and onRoad into numeric constraints over positions, headings, dimensions, fields of view, non-intersection, and containment in road polygons. Static inconsistency detection operates before numeric solving, and metaheuristic search then resolves the numeric scene as an unconstrained minimization problem (Babikian et al., 2023).

5. Learning, knowledge, and human-facing frameworks

Some frameworks make abstraction a first-class cognitive or pedagogical object. CAFÉ 2.0 organizes introductory programming work so that the resolution flow runs through two phases: the abstraction one and the concrete one. In the CS1 instantiation, students build a Graphical Loop Invariant model through sequential productions—GLI tab, Initial Representation, Final Representation, Loop Variant Function, and Code Editor—and the system produces personalized feedback not only on the final code but also on how the solution was modeled and how consistent the model is with the code (Brieven et al., 2023).

Research on learned abstraction treats transfer as the operational signature of abstraction. The probing framework built around tasks $\alpha$2, $\alpha$3, and contrast task $\alpha$4 defines abstraction as the ability to induce abstract concepts from concrete instances and reuse them flexibly beyond the original context. In the grammar probe, T5 and GPT-2 show large gains for $\alpha$5 over $\alpha$6, while $\alpha$7 remains close to the control condition, and the training dynamics exhibit a “memorize-then-abstract” two-stage process (An et al., 2023).

Commonsense knowledge work uses conceptualization as an abstraction-concretization loop over events and concepts. An abstract commonsense knowledge graph is induced by identifying candidates in ATOMIC events, conceptualizing them with concepts from Probase and WordNet, validating abstract events and abstract triples, and then reusing the resulting abstract knowledge to infer about unseen entities or situations. The produced graph contains about 70K abstract events, 229.2K event conceptualizations, and 2.95M abstract triples (He et al., 2022).

Knowledge-graph benchmarking formalizes the same loop at the interface between entity-level and ontology-level knowledge. KACC models a comprehensive KG as an entity-concept KG with instance-level entity graph, ontology-level concept graph, and cross-view instanceOf links. It then defines Knowledge Abstraction, Knowledge Concretization, and Knowledge Completion, including multi-hop variants justified by transitivity rules for instanceOf and subclassOf. The benchmark demonstrates that multi-hop hierarchy reasoning remains difficult and that concretization is harder than abstraction for the evaluated models (Zhou et al., 2020).

Human-computer interaction frames abstraction as a property of both systems and users’ mental models. The Abstraction Spaces framework synthesizes six dimensions—Unit of Interest, Granularity, Representation, Transformability, Presentation, and Guidance—and reframes Norman’s model with a Gulf of Abstraction, defined as the misalignment between the user’s mental model and the system’s representation of information. This formulation explicitly allows alignment and deliberate misalignment, as well as abstraction overshoots and undershoots (Min et al., 11 May 2026).

6. Soundness, limitations, and recurrent tensions

A notable feature of abstraction-concretization frameworks is the prominence of correctness claims. In traffic-scene concretization, Theorem 1 states that if the numeric problem has a solution, abstracting that solution back yields a concrete partial model refining the original functional scene specification, $\alpha$8, and Theorem 2 states that any metaheuristic-search solution to the minimization problem is a valid solution of the numeric scene problem (Babikian et al., 2023). In probabilistic program abstraction, a theorem shows that probabilistic soundness coincides with non-deterministic soundness after lowering to support sets, thereby connecting the probabilistic framework back to the classical abstraction story (Holtzen et al., 2017).

At the same time, the literature is explicit about incompleteness and tradeoffs. Static inconsistency detection for functional scene specifications is sound but incomplete: if error arises, no concrete solution exists; if no error arises, consistency is not guaranteed (Babikian et al., 2023). In controller synthesis, any ASR abstraction can be completed to an MCR abstraction, but the price is increased non-determinism in the abstraction (Calbert et al., 2024). In logic-based abstraction, the tightest abstraction is always expressible in propositional logic, but in first-order logic it may require second-order quantification and may therefore fail to be first-order definable (Szalas, 30 Oct 2025).

A common misconception is that abstraction is always monotone simplification toward “higher-level” descriptions. The surveyed literature is more cautious. Abstraction may hide implementation details, but it may also expose structure, add detail needed for analysis, or alter the form of interaction rather than merely compressing it. Another misconception is that concretization is only code generation or only refinement to implementation. In the research corpus, concretization variously means controller refinement, numeric instantiation, realization of abstract semantics, execution-level realization, generation of GUI events and assertions, or inheritance of abstract commonsense knowledge by a new event (Diertens, 2012, Zhang et al., 2024, He et al., 2022).

The broader implication is that abstraction-concretization frameworks are less a single doctrine than a family of rigorously specified bridges between levels of description. Their technical content lies in the bridge itself: the maps, operators, relations, validity rules, or interfaces that determine what may be forgotten, what must be preserved, and how abstract structure becomes concrete action again.