Two-Stage Abstraction and Refinement

• Two-Stage Abstraction and Refinement (ABS-REF) is a framework that decomposes a process into a coarse abstraction step for tractable reasoning followed by a refinement step for precision recovery.
• ABS-REF is applied in diverse domains like point cloud processing, software verification, and controller synthesis to balance efficiency with detailed accuracy.
• The approach supports iterative computational schemes that improve results incrementally while ensuring error discovery and accommodating emergent behaviors.

Searching arXiv for recent and directly relevant papers on Two-Stage Abstraction and Refinement and closely related abstraction-refinement frameworks. Two-Stage Abstraction and Refinement (ABS-REF) denotes a decomposition in which a system is first represented at a coarser, more structured, or more tractable level and is then specialised, corrected, or contextually improved in a second stage. In the point-cloud literature this terminology is explicit: abstraction (ABS) downsamples points and aggregates local neighborhoods, whereas refinement (REF) keeps resolution fixed and improves feature representations through contextual aggregation (Zou et al., 4 Mar 2026). Across adjacent literatures, the same two-stage reading also appears as an interpretive lens on refinement-based software evolution, verification, synthesis, control, and model-based development, although the label itself is not always canonical in those domains (Ailane et al., 2022).

1. Core meaning and canonical structure

In its most explicit form, ABS-REF factors a processing pipeline into two distinct operators over a state or feature representation. For point clouds, a layer $l$ carries point coordinates and features $(\mathcal{P}^l,\mathcal{F}^l)$. The ABS stage performs sampling, grouping, and intra-set aggregation: $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$

$$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$

$$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$

REF then preserves point resolution and applies inter-set aggregation on the downsampled set: $$\mathcal{D}^{l+1}_{REF}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{REF}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^{l+1}, \mathcal{F}^{l+1}_{ABS}),$$

$$f_m^{l+1} = h_{REF}\big(\mathcal{D}^{l+1}_{REF}(p_m^{l+1}), \mathcal{K}^{l+1}_{REF}(p_m^{l+1})\big).$$

ABS is thus analogous to strided convolution or pooling, while REF is analogous to fixed-resolution residual or transformer blocks (Zou et al., 4 Mar 2026).

This explicit architectural reading generalises. The literature considered here suggests three recurrent ABS-REF patterns. First, ABS may mean state-space or representation compression, with REF reintroducing distinctions only where analysis remains inconclusive. Second, ABS may mean stepwise semantic generalisation, with REF enforcing relative correctness by restricting behaviors. Third, ABS may mean high-level requirements modelling, with REF providing a traceable descent toward executable or deployable artefacts. The common denominator is not a single calculus but a two-part control structure: tractable coarse reasoning followed by targeted precision recovery.

2. Formal semantics of abstraction and refinement

A standard semantic foundation is given by the Abstraction Refinement Model (ARM), which treats software evolution through a universe of models $M$, a universe of behavior traces $BT$, and a semantic function

$sem : M \rightarrow \mathcal{P}(BT),$

together with an evolution function

$(\mathcal{P}^l,\mathcal{F}^l)$0

A development step is an abstraction when

$(\mathcal{P}^l,\mathcal{F}^l)$1

and a refinement when

$(\mathcal{P}^l,\mathcal{F}^l)$2

Under the classical refinement discipline, the final observed behavior remains included in earlier semantic stages: $(\mathcal{P}^l,\mathcal{F}^l)$3 This is the formal content of the usual “no extra behavior” guarantee (Ailane et al., 2022).

The same framework becomes two-stage once emergent behavior is admitted. The extended ARM defines emergent behavior as behavior “not specified during development but appears (is observed) at run-time,” represented by $(\mathcal{P}^l,\mathcal{F}^l)$4. It also introduces unspecified observed behavior traces $(\mathcal{P}^l,\mathcal{F}^l)$5 and $(\mathcal{P}^l,\mathcal{F}^l)$6, and replaces the strict closed-world reading with an extended-closed world assumption inspired by circumscription. A direct two-stage reading then separates: first, classical abstraction/refinement for the concrete or specified part of the model; second, diagnosis and reintegration of unspecified or emergent behavior discovered during testing and operation. In that reading, refinement is preserved on the concrete core while the total semantics may still contain an extra, explicitly tracked behavior part (Ailane et al., 2022).

A complementary logical semantics is provided by the modal logic of abstraction refinement. There, transition systems themselves are treated as worlds, with $(\mathcal{P}^l,\mathcal{F}^l)$7 meaning that $(\mathcal{P}^l,\mathcal{F}^l)$8 is a refinement of $(\mathcal{P}^l,\mathcal{F}^l)$9 via a surjective abstraction function that preserves labels, transitions, and initial states. The modal operators are interpreted as

• $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$0: “there is a refinement, in which …”
• $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$1: “in all refinements, …”

For CTL-definable properties, this yields lower and upper modal bounds that depend on the refinement universe considered: S4 is always valid; S4.2 appears when finite abstractions of a fixed system are directed; S4.2.1 arises when all abstractions of a fixed system are considered and a greatest element exists (Piribauer et al., 9 Jan 2026). This gives ABS-REF a metalogical interpretation: refinement is not only an operational step but also a modal transition over spaces of models.

3. Iterative computational schemes

In algorithmic settings, ABS-REF usually appears as an iterative loop: construct an abstract search space, solve there, validate or interpret the result concretely, and refine if the abstraction was too coarse. Representative instances include SYNGAR for program synthesis, abstract-interpretation-assisted trace abstraction, Cnn-Abs for CNN verification, nonuniform abstraction-refinement for controller synthesis, abstraction-based web-service composition, learned refinement for Datalog analyses, and refinement by auxiliary variables in model checking (Wang et al., 2017, Greitschus et al., 2017, Ostrovsky et al., 2022, Bulancea et al., 2018, Chattopadhyay et al., 2016, Grigore et al., 2015, Tian et al., 2010).

Domain	ABS stage	REF stage
Program synthesis	Coarse abstract semantics; AFTA search	Concrete checking; proof-of-incorrectness refinement
Software model checking	Path program + abstract interpretation	SMT fallback; data-automaton refinement
CNN verification	Remove convolutional connections; bounded abstract inputs	Restore abstracted neurons and edges
Controller synthesis	Coarse finite transition system over nonuniform partition	Fixed-point-guided cell splitting
Web service composition	Compose over abstract service groups	QoS repair or structural de-abstraction

SYNGAR exemplifies the pattern in synthesis. It uses abstract semantics of a DSL to find a program whose abstract behavior satisfies examples, then iteratively refines the abstraction when the candidate is spurious with respect to concrete semantics. The framework is built around abstract finite tree automata and was implemented in BLAZE; on matrix manipulations, BLAZE yielded a $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$2 speed-up over Prose (Wang et al., 2017). The crucial ABS-REF separation is between abstract search and concrete falsification-guided repair of the abstraction.

Trace abstraction refined by abstract interpretation exhibits a different two-stage division. An infeasible trace is first lifted to a path program that may contain loops; abstract interpretation is then used to derive loop invariants whenever possible. Only if that analysis is indefinite does the method fall back to SMT-based refinement. On 214 SV-COMP benchmarks, the OCT+CON configuration solved 103 instances, compared with 97 for the baseline Automizer configuration, indicating that the AI-first stage can reduce refinement iterations in loop-heavy cases (Greitschus et al., 2017).

In CNN verification, Cnn-Abs removes convolutional connections so as to soundly over-approximate the original network and restores them if the abstraction becomes too coarse. The framework is front-end agnostic with respect to the backend verifier, and its evaluation reports a 15.7% average runtime reduction relative to the underlying state-of-the-art engine (Ostrovsky et al., 2022). In controller synthesis, abstraction-refinement with nonuniform partitions couples fixed-point characterisations of temporal objectives with selective geometric partition refinement and novel BDD encodings, again matching the ABS-REF pattern of coarse symbolic solution followed by local refinement (Bulancea et al., 2018).

Two further instances shift the balance between prediction and structural change. For parametric Datalog analyses, a learnt probabilistic model assigns each untried abstraction a probability of success, while abstraction size estimates cost; the next abstraction is chosen by combining these two quantities optimally (Grigore et al., 2015). In contrast, a model-checking refinement scheme avoids the NP-hard state-separation problem by adding new Boolean variables to the abstract model instead of promoting hidden concrete variables, yielding a smaller refined abstract model and linear-time refinement in the size of the state space (Tian et al., 2010). In QoS-constrained service composition, the abstract stage composes over successive abstractions $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$3 through $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$4, and the refinement stage either repairs QoS assignments locally or reconstructs the solution on a less abstract graph; on a synthetic repository, reported speed-ups reached $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$5 before the method had to fall back toward the concrete graph (Chattopadhyay et al., 2016).

4. ABS-REF as an architectural principle in point cloud processing

The most explicit use of the term ABS-REF is the point-cloud framework that treats feature extraction as a two-stage pipeline. A point cloud with $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$6 points is written as points $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$7 and features $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$8. ABS reduces point count and builds higher-level features through local aggregation; REF preserves the downsampled resolution and expands effective receptive field through same-resolution contextual aggregation. Earlier networks such as PointNet++, PointConv, RepSurf, and PAConv are described as ABS-only, whereas Point Transformer, PointMixer, PointNeXt, Stratified Transformer, ASSANet, and PointMetaBase are treated as architectures with both ABS and REF (Zou et al., 4 Mar 2026).

The paper also introduces a separable ABS-REF view of local aggregation. A grouped-neighborhood operator is decomposed into grouping $\mathcal{P}^{l+1} = \mathrm{FPS}(\mathcal{P}^l),$9, pointwise transformation $$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$0, and reduction $$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$1, yielding three variants: $$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$2

$$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$3

$$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$4

In REF, where $$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$5, Conv is $$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$6 times more expensive than PreConv and ProConv. This motivates replacing traditional local MLPs with non-local MLPs plus cheap reductions.

To recover local geometric detail after that replacement, the framework introduces High-dimensional Positional Encoding (HPE). HPE is translation invariant because it is applied to relative coordinates, and it maps $$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$7-D geometry into a higher-dimensional embedding. Two instantiations are given: a sinusoidal version $$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$8 and a learnable two-layer MLP version $$\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{ABS}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^l, \mathcal{F}^l),$$9. HPE is added element-wise to grouped features in both ABS and REF; in REF it can be shared across multiple layers because point positions do not change.

These ingredients define HPENets. HPENet V2 uses PreConv-style non-local MLPs in most ABS and REF blocks, retains Conv in the first ABS stage, and adds a Backward Fusion Module in the decoder. The reported empirical picture is that adding REF to an ABS-only model yields $$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$0 mIoU on S3DIS Area-5; adding PE yields a further $$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$1 mIoU; replacing PE with HPE adds another $$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$2 or more. In headline results, HPENet surpasses PointNeXt by $$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$3 mAcc, $$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$4 mIoU, $$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$5 mIoU, and $$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$6 Cls. mIoU, with only $$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$7, $$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$8, $$f_m^{l+1} = h_{ABS}\big(\mathcal{D}^{l+1}_{ABS}(p_m^{l+1}), \mathcal{K}^{l+1}_{ABS}(p_m^{l+1})\big).$$9, and $$\mathcal{D}^{l+1}_{REF}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{REF}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^{l+1}, \mathcal{F}^{l+1}_{ABS}),$$0 of FLOPs on ScanObjectNN, S3DIS, ScanNet, and ShapeNetPart, respectively (Zou et al., 4 Mar 2026).

5. Domain extensions and applied interpretations

Outside point-cloud learning, ABS-REF frequently acts as a cross-domain organisational principle rather than a single named algorithm. In Event-B, the central issue is not runtime verification but refinement planning. Artifacts from the natural-language specification induce required phenomena through typing and event constraints, and the planning method searches for orders of introducing artifacts that lexicographically minimise the sorted counts of newly introduced phenomena at each abstraction level. This effectively makes ABS the planning of abstraction levels and REF the subsequent construction of the Event-B refinement chain (Kobayashi et al., 2012).

Model-based development uses a different split. Abstract requirement models and concrete design models are both given FOCUS-style stream semantics, and the relation between them is mediated either by input/output correspondence relations $$\mathcal{D}^{l+1}_{REF}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{REF}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^{l+1}, \mathcal{F}^{l+1}_{ABS}),$$1, $$\mathcal{D}^{l+1}_{REF}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{REF}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^{l+1}, \mathcal{F}^{l+1}_{ABS}),$$2, or by an abstraction–concretisation pair $$\mathcal{D}^{l+1}_{REF}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{REF}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^{l+1}, \mathcal{F}^{l+1}_{ABS}),$$3 satisfying a Galois-connection condition. Test cases are generated on the abstract model and then reused at the concrete level through concretisation components and output checkers. This is a two-stage refinement discipline in which ABS supplies requirement-level behavior and REF reuses those traces to validate concrete realizations, while explicitly acknowledging that the method “cannot completely prove the refinement” (Blech et al., 2012).

Stochastic verification yields yet another variant. For Markov automata, menu-based abstraction is used for probabilistic blocks and game-based abstraction for Markovian blocks, producing a two-player stochastic game $$\mathcal{D}^{l+1}_{REF}(p_m^{l+1}),\; \mathcal{K}^{l+1}_{REF}(p_m^{l+1}) = \mathrm{KNN}(p_m^{l+1}, \mathcal{P}^{l+1}, \mathcal{F}^{l+1}_{ABS}),$$4. Lower and upper time-bounded reachability probabilities are then computed via discretisation and value iteration, and refinement is triggered when the gap between them exceeds the desired precision. The partition is split according to disagreements between abstract schedulers, guided by a pseudo-metric on successor distributions. ABS is therefore a partition-based game abstraction, and REF is scheduler-guided block splitting (Braitling et al., 2014).

These applications show that ABS-REF is not restricted to one semantic substrate. The same two-stage decomposition appears over stream semantics, refinement lattices, stochastic games, service graphs, and learned provenance hypergraphs. What changes is the object being abstracted: points, traces, rule instances, services, or specification artifacts.

6. Guarantees, limitations, and open issues

The strongest guarantees arise when refinement is interpreted as semantic restriction. In the classical ARM under the closed-world assumption, refinement at every step implies that no emergent behavior can exist, because observed runtime behavior remains included in requirement behavior. Once the framework is extended to admit incompleteness, the guarantee weakens: refinement is preserved only for the concrete or specified part, while the unknown or emergent part is explicitly tracked rather than excluded (Ailane et al., 2022). This distinction is fundamental. ABS-REF does not invariably mean “correct by construction”; in some settings it means “correct on the specified core, diagnostically explicit on the unspecified remainder.”

A second class of guarantees concerns sound bug finding. Under predicate abstraction with under-approximation refinement, all analyzed behaviors are feasible by definition, so errors to safety properties are preserved. The same work states that if the possibly infinite concrete system has a finite bisimulation quotient, the method is guaranteed eventually to explore an equivalent finite bisimilar structure [0701140]. This is a different guarantee from over-approximate CEGAR, but it still fits the ABS-REF landscape: abstraction is partial and safe for error discovery, refinement expands precision until a bisimulation-adequate quotient is reached.

Algorithmic refinements may also target tractability rather than expressiveness. One model-checking approach avoids the NP-hard state-separation problem by adding new Boolean variables to the abstract model instead of making previously invisible concrete variables visible, thereby obtaining a smaller refined abstract model (Tian et al., 2010). Conversely, some proposals remain primarily semantic. The extended ARM for emergent behavior explicitly notes that no operational algorithm or tool is yet provided for automatically identifying emergent behaviors or updating models (Ailane et al., 2022).

A common misconception is that refinement monotonically stabilises arbitrary temporal properties. The logical results do not support that generalisation. For CTL, truth values can change under refinement, and the strongest universal modal principles depend on the refinement universe considered: S4 always, S4.2 for all finite abstractions of a fixed system, and S4.2.1 when all abstractions of a fixed system are available (Piribauer et al., 9 Jan 2026). Likewise, not every ABS-REF scheme yields average-case gains without worst-case fallback: the service-composition framework explicitly states that, in the worst case, it may end up exploring the complete composition graph constructed on individual services (Chattopadhyay et al., 2016).

The literature considered here therefore suggests that ABS-REF is best understood as a family of two-stage research patterns rather than a single standardised formalism. One branch treats ABS and REF as architectural stages in representation learning; another treats them as an iterative CEGAR-style loop over provers, schedulers, or search spaces; a third treats them as cross-level traceability mechanisms between requirements and implementations. The unifying principle is the deliberate separation of coarse tractable reasoning from a second, more selective recovery of semantic detail.