Domain Abstraction in Complex Systems

• Domain abstraction is the process of constructing higher-level representations of a domain’s key concepts, constraints, and behaviors to enable efficient reasoning.
• It employs techniques such as state aggregation, quotienting by behavioral equivalence, and hierarchical modeling to simplify complex domains.
• This approach is applied across AI planning, software verification, and scientific computing to enhance performance and maintain critical structural details.

Domain abstraction is the construction of a higher-level representation of a domain’s concepts, constraints, workflows, or behaviors so that planning, verification, optimization, simulation, or explanation can be carried out on a simpler model without discarding the structure that matters for the target task. Across recent literature, the term denotes several closely related practices: representing a domain’s intrinsic task-dependency graph and aligning agent architecture to it, replacing concrete states or actions with aggregated symbolic ones, collapsing multi-domain PDE models into a single mixed variational problem, organizing infinite-dimensional problems around product domains and measures, and defining guard- or usage-sensitive abstract domains for verification and synthesis (Li et al., 21 Nov 2025, Pulsipher et al., 2021, Sagiyama et al., 5 Dec 2025, Schüler et al., 2023, Apel et al., 2013).

1. Conceptual scope and foundational perspective

A general software- and AI-oriented account treats domain abstraction as an engineered representation of a domain—its concepts, assumptions, constraints, and behaviors—used to build, analyze, and operate software and AI-intensive systems. In that view, domain models, conceptual models, domain-specific languages, modeling and simulation abstractions, and ontologies are all domain-level abstractions, distinguished from implementation abstractions, algorithmic abstractions, and architectural abstractions (Bencomo et al., 2024).

The same line of work argues that abstraction should not be treated as an isolated modeling convenience but as a systematic engineering discipline spanning both deductive and inductive spaces. Deductive abstractions are explicit, formally specified, and tied to correctness, refinement, and verification; inductive abstractions are learned or statistical, tied to training data, loss functions, and approximate models. This is formalized by the contrast between abstraction functions and concretization relations familiar from formal methods, and learned models of the form

$h^\* = \arg\min_{h \in \mathcal{H}} L(h; D),$

which summarize regularities in data rather than enumerating concrete cases (Bencomo et al., 2024).

Several design questions recur across the literature: purpose, scope and boundaries, granularity, formality, interpretability, composability, and traceability. This suggests that domain abstraction is not a single method but a design problem: one chooses what part of a domain to preserve explicitly, what to compress, and what representation makes that compression operational for the downstream reasoning task (Bencomo et al., 2024).

2. Recurring formal patterns

Despite the diversity of applications, several formal patterns recur. In hierarchical agent design, the domain is encoded as a task-dependency graph

$\mathcal{G} = (V, E),$

where vertices are atomic operations, tools, or tasks, and directed edges encode prerequisite constraints; topological stratification then induces abstraction layers $V=\bigcup_{l=1}^{L} V_l$ (Li et al., 21 Nov 2025). In infinite-dimensional optimization, the domain is a Cartesian product

$$\mathcal{D} := \prod_{\ell \in \mathcal{L}} \mathcal{D}_\ell,$$

with measures and differential operators defined over its factors (Pulsipher et al., 2021). In multi-domain finite elements, unknowns over distinct meshes or submeshes are unified as a single mixed space

$V = V_{i_0} \times \cdots \times V_{i_{M-1}},$

and coupled through intersection measures over overlapping cells, facets, or interfaces (Sagiyama et al., 5 Dec 2025).

A second pattern is quotienting by behavioral equivalence. In database manipulating systems, the concrete domain is the powerset of all valid databases, and abstract domains are built by union, intersection, or homomorphism-based constructions with labeled nulls so that databases equivalent with respect to a guard fragment are unified into one abstract element (Schüler et al., 2023). In strategy-game search, state abstraction is a map

$\phi: \mathbb{S} \rightarrow \mathbb{S}_\phi,$

clustering concrete states into abstract states by approximate reward and transition similarity (Xu et al., 2022). In software model checking, variables are assigned to abstract domains according to usage-derived domain types such as Bool, IntEq, IntEqAdd, and Int, rather than their declared language types (Apel et al., 2013).

A third pattern is purpose alignment. The abstraction criterion is not merely compression but relevance to a task. In one line of work, abstraction is selected to support planning and procedural correctness; in another, to preserve the information needed for sentiment, helpfulness, or category recognition under a length budget; in another, to make hybridization, static condensation, or safety verification computationally feasible (Li et al., 21 Nov 2025, Muhammad et al., 2019, Gibson et al., 2018).

3. Planning, generalized reasoning, and agent architecture

A particularly explicit treatment appears in hierarchical task abstraction for domain-specific agents. There, domain abstraction is defined as explicit modeling of a domain’s intrinsic task structure and then using that structure to shape the agent architecture itself. The Hierarchical Task Abstraction Mechanism begins from a task-centric rather than role-centric view: instead of assigning agents human-like roles, it derives a logical hierarchy from a domain DAG and uses top-down planning with layer-specific policies followed by bottom-up execution through layerwise transformations (Li et al., 21 Nov 2025).

EarthAgent instantiates this idea for remote sensing and geospatial analysis with three layers: data acquisition and preprocessing; data processing and analysis; and synthesis and application. The architecture is constrained so that higher-level reasoning depends on outputs from lower layers, which enforces order correctness by construction. GeoPlan-bench evaluates this kind of planning with metrics for key-tool recall and precision, weighted PathSimilarity, and an Elo-based logical completeness score. In the reported ablation, removing hierarchy drops $F1_{\text{key}}$ from $0.62$ to $0.39$, while structural similarity changes only from $0.66$ to $\mathcal{G} = (V, E),$0, indicating that superficially plausible plans can still miss critical domain steps (Li et al., 21 Nov 2025).

Generalized planning for ARC adopts a different but related abstraction strategy. GPAR replaces raw grids of colored pixels with an object-centric planning domain whose nodes can be connected components, same-color regions, lines, pixels, or the whole image. These nodes carry attributes such as color, size, shape, and containment or spatial relations, and planning is then performed in PDDL with external functions and planning programs with pointers over the abstract objects (Lei et al., 2024). On 160 object-centric ARC tasks, GPAR solved 81, compared with 64 for the Kaggle solution and 57 for ARGA, which the paper attributes to this layered object-centric abstraction (Lei et al., 2024).

A recent LLM-oriented planning line treats abstraction itself as the synthesis target. Given a concrete PDDL domain, a problem instance, and a natural-language purpose of abstraction, GPT-4o is prompted to generate an abstract PDDL domain and problem by abstracting alternative concrete actions, sequences of concrete actions, action or predicate parameters, or combinations of these. Symbolic tools and human experts then validate the result. The reported outcome is that GPT-4o can generally synthesize useful planning domain abstractions in simple settings, and is better at abstracting over actions than over the associated fluents (Banihashemi et al., 23 Oct 2025).

4. Verification, model checking, and symbolic abstraction

In verification, domain abstraction is often the mechanism that makes finite-state reasoning possible. For B event systems, one approach combines state variable elimination with domain abstraction of the remaining variables. A preliminary syntactic abstraction suppresses variables not relevant to a test purpose; semantic abstraction over the retained variables then produces a finite symbolic state system suitable for model-based testing. The paper proves one construction that yields a simulation and another that yields a bisimulation, depending on how relevant variables are chosen (Julliand et al., 2010).

Software model checking uses a finer-grained version of the same idea. Domain types classify variables by usage rather than declared type, and this classification guides the choice of abstract domain per variable. The study compares an explicit-value domain with a BDD-based symbolic domain across benchmark families and shows that the assignment matters substantially: Bool and IntEq variables are often advantageous in BDDs, whereas arithmetic-heavy Int variables are often better left to explicit tracking (Apel et al., 2013). This suggests that domain abstraction can be variable-local rather than program-global.

Database manipulating systems push the idea further toward language-relative semantics. The concrete domain is $\mathcal{G} = (V, E),$1, and abstract domains are tailored to fragments of the guard language. Union-based abstractions preserve conjunctions of negated atoms, intersection-based abstractions preserve projection-free conjunctive guards, and homomorphism-based abstractions with labeled nulls preserve richer conjunctive or normal conjunctive guards up to bisimilarity (Schüler et al., 2023). Here the abstraction boundary is defined by what observations a guard language can express.

Taken together, these works treat domain abstraction in verification not merely as reduction of size, but as the selection of the coarsest representation that still preserves the property language, test purpose, or analysis precision of interest.

5. Scientific computing, optimization, and numerical domains

In scientific computing, domain abstraction frequently denotes a unified representation of multiple physical or geometric domains. For multi-domain finite elements, a new abstraction represents problems over several meshes, cell types, or codimensions as an ordinary mixed variational problem on a single product space, with intersection measures such as $\mathcal{G} = (V, E),$2 or mixed cell-facet measures expressing overlap and interface coupling (Sagiyama et al., 5 Dec 2025). The implementation in UFL and Firedrake uses MeshSequence, CellSequence, MixedElement, and intersection-aware measures so that quad–triangle, hex–quad, and fluid–structure interaction problems can be written as a single residual $\mathcal{G} = (V, E),$3 with a single Jacobian $\mathcal{G} = (V, E),$4 (Sagiyama et al., 5 Dec 2025).

A related software-layer view appears in Slate, which extends Firedrake’s domain-specific abstraction from PDE weak forms to element-local dense tensor algebra. Rather than hard-coding hybridization or static condensation, Slate provides symbolic operations on local tensors—block extraction, inverses, local solves, and Schur complements—and compiles them into performant kernels. This turns hybridization and static condensation into reusable, runtime-configurable solver components rather than application-specific code paths (Gibson et al., 2018).

Infinite-dimensional optimization adopts a measure-centric abstraction. Every infinite-dimensional problem is organized around domains $\mathcal{G} = (V, E),$5, their product $\mathcal{G} = (V, E),$6, infinite variables $\mathcal{G} = (V, E),$7, differential operators $\mathcal{G} = (V, E),$8, and measures $\mathcal{G} = (V, E),$9 that map infinite-dimensional functions to scalars. This allows continuous-time optimal control, PDE-constrained optimization, stochastic optimization, and combinations such as stochastic PDEs to be written in a single template (Pulsipher et al., 2021). The abstraction is powerful precisely because time, space, and uncertainty are treated uniformly as domains rather than as separate modeling regimes.

For nonlinear dynamics, domain abstraction can also mean a conservative surrogate model. Incremental affine abstraction replaces a nonlinear system on a bounded domain by upper and lower affine hyperplanes

$V=\bigcup_{l=1}^{L} V_l$0

computed by a sequence of linear programs over expanding operating regions. The benefit is reduced space complexity relative to a single global LP; the cost is potentially worse over-approximation (Hassaan et al., 2020).

6. Learned abstraction, evaluation, and open problems

Several recent works replace manual abstraction design with data-driven or learned surrogates. Elastic MCTS uses approximate MDP homomorphism to cluster search-tree nodes online, then declusters them after an iteration threshold. It reduces tree size by a factor of $V=\bigcup_{l=1}^{L} V_l$1 and performs best when abstraction is active for roughly $V=\bigcup_{l=1}^{L} V_l$2 to $V=\bigcup_{l=1}^{L} V_l$3 of the search budget; using abstraction for $V=\bigcup_{l=1}^{L} V_l$4 of the search hurts performance, showing that coarse abstraction helps exploration but can harm final discrimination (Xu et al., 2022).

Game abstraction can also be learned from corpora of play. A domain-independent method treats actions as words and gameplay traces as sentences, learns action embeddings with GloVe or foundational embedding models, and clusters those embeddings to define abstract actions. The paper reports that the technique is effective and broadly transferable across games, although it does not outperform specialized algorithms tailored to specific games (Kim et al., 15 May 2026). In sequence abstraction, a reinforcement-learning framework selects strokes, video segments, or sentences under a budget to preserve a specified goal such as category, attribute, sentiment, or helpfulness, and does so without human-defined ideal abstractions (Muhammad et al., 2019).

At the semantic level, AbsPyramid provides a unified entailment graph of 221K textual descriptions of abstraction knowledge over nouns, verbs, and events, treating abstraction as contextual linguistic entailment between a concrete head event and a more abstract tail event (Wang et al., 2023). That benchmark shows that current LLMs still struggle with abstraction in zero-shot and few-shot settings, but that training on rich abstraction knowledge improves generalization to unseen events (Wang et al., 2023).

Evaluation criteria vary by field, but recurring quality goals are stable: correctness or soundness, expressiveness, usability, composability, robustness, explainability, and scalability (Bencomo et al., 2024). In planning, evaluation may target key-step recall, path similarity, and logical completeness (Li et al., 21 Nov 2025); in search, compression rate and downstream performance (Xu et al., 2022); in numerical domains, approximation error and convergence (Sagiyama et al., 5 Dec 2025, Hassaan et al., 2020). A persistent limitation across the literature is that abstraction design still depends heavily on human choices: task graphs are often expert-built, abstraction layers are not guaranteed to be optimal, workflow rollbacks and non-linear jumps remain difficult to encode, and automated selection of the “right” abstraction for a new domain remains an open problem (Li et al., 21 Nov 2025, Bencomo et al., 2024).