Multi-resolution Abstraction Synthesis

• MRASP is a framework that synthesizes finite, variable-resolution system abstractions to efficiently support verification and controller design.
• It employs counterexample-guided refinement and adaptive mesh strategies to manage local error bounds in continuous, stochastic, and partially observed systems.
• Implementations demonstrate up to 50% model size reduction while ensuring soundness and convergence for δ-UB systems and other complex dynamics.

The Multi-resolution Abstraction Synthesis Problem (MRASP) concerns the automated synthesis of system abstractions—finite, tractable models capturing essential behaviors at varying levels of fidelity to support verification, controller design, code synthesis, and domain reasoning. MRASP arises in domains where different regions or aspects of a system require distinct levels of modeling precision, typically due to scalability constraints, heterogeneous requirements, or limitations in available sensing and observation. Recent research has developed theoretical foundations, algorithms, and practical frameworks to support MRASP in settings such as continuous, stochastic, and partially observed systems, program analysis, optimization, and graph data synthesis.

1. Theoretical Foundations of Multi-resolution Abstraction

A core concept underpinning MRASP is variable-resolution abstraction: the construction of system models that enforce stronger error bounds or more detailed representations in specific regions, while permitting coarser approximations elsewhere. For continuous-state deterministic systems, this is formalized via multi-resolution approximate bisimulations, as in (Coppola et al., 22 Sep 2025). Here, abstraction precision is prescribed locally through a resolution function $\epsilon(x, q)$, yielding a relation

$$\overline{R} = \{ (x, q) \in X \times X : d(x, q) \leq \epsilon(x, q)\},$$

which generalizes classical uniform $\epsilon$-bisimulations to state-dependent fidelity requirements. The existence of multi-resolution bisimilar abstractions is guaranteed for all incrementally uniformly bounded (δ-UB) systems, as proved in Theorem 4 of (Coppola et al., 22 Sep 2025). Some systems admit multi-resolution bisimulations even when no uniform $\epsilon$-approximate bisimulation exists—demonstrating significant power of the generalized framework.

Predicate abstraction and knowledge-based subset construction further enrich the abstraction toolkit, enabling finite-state games and verification under partial observation constraints (Fu et al., 2014).

2. Counterexample-guided Synthesis and Mesh Refinement

MRASP synthesis algorithms frequently employ inductive refinement procedures. A prominent method is Counterexample-Guided Inductive Synthesis (CEGIS), which combines a candidate abstraction generator (learner) and a satisfiability-based verifier (Coppola et al., 22 Sep 2025). The learner selects a finite mesh covering the state space, clustering concrete states and proposing relation parameters (e.g., radii of mesh cells). Satisfiability modulo theories (SMT) verification identifies counterexample states where the current abstraction fails coverage or transition consistency constraints; these are incorporated for mesh refinement.

The CEGIS loop thus operates at two levels:

• Low-level refinement: Counterexamples trigger adjustments to candidate relation parameters, tightening abstraction locally.
• High-level mesh refinement: Infeasibility leads to local mesh splitting, increasing resolution only where required by specification or system behavior.

For systems with partial observation, counterexamples extracted during reactive controller synthesis (such as abstract counterexample trees in (Fu et al., 2014)) can be analyzed to discern unrealizability due to sensing limitations or excessive abstraction coarseness. Interpolant-based refinement techniques extract new predicates (sensor or behavioral properties) to incrementally refine precision.

3. Algorithms and Practical Implementations

MRASP frameworks implement scalable abstraction synthesis for high-dimensional, nonlinear, and non-differentiable systems. In (Coppola et al., 22 Sep 2025), automatic abstraction construction proceeds by clustering trajectories, defining locally adaptive resolution bounds, and employing SMT-based refinement. Soundness is assured for δ-UB systems, and the approach is shown to terminate for key classes.

Abstraction procedures are also employed for software and program synthesis: symbolic execution combined with LLM invariant generation enforces multi-abstraction function summaries for safety-critical code (see (Yang et al., 11 Jun 2025)). In optimization contexts, Harten’s Multiresolution Framework decomposes problems into hierarchies of nested discretizations, solving auxiliary lower-dimensional subproblems and improving accuracy through interpolation (Donat et al., 2022).

When controller synthesis is desired (e.g., for stochastic systems (Dutreix et al., 2020)), finite-state abstractions are constructed by partitioning continuous domains into regions with compatible labeling, overapproximating the stochastic reachability, and synthesizing bounded-parameter Markov Decision Processes (BMDPs). Refinement is performed through specification-guided splitting, driven by metrics such as the controller suboptimality factor.

4. Applications to Verification, Control, and Program Synthesis

MRASP frameworks facilitate formal verification, reactive controller synthesis, architectural modeling, and program specification in several domains:

• Formal verification: Multi-resolution bisimulations broaden symbolic verification to systems that lack uniform stability (including non-$\delta$-GAS systems) (Coppola et al., 22 Sep 2025).
• Control synthesis: Finite-state abstractions derived at locally adaptive resolutions enable robust controller design, enforcing tight error bounds where necessary (Dutreix et al., 2020).
• Program analysis: Automated synthesis of function summaries at varying abstraction levels supports both verification-grade rigor and human comprehensibility (Yang et al., 11 Jun 2025).
• Robotic motion planning and sensor design: Abstraction refinement informs required sensing modalities and their granularity, as demonstrated in motion planning under partial information (Fu et al., 2014).

Experiments consistently show that adaptive, multi-resolution abstractions yield models up to 50% smaller than canonical uniform gridding approaches, while maintaining or improving error guarantees, scalability, and synthesis speed.

5. Error Guarantees, Scalability, and Termination Properties

A critical aspect of MRASP frameworks is the enforcement of location-dependent error bounds, enabling abstractions to allocate modeling resources efficiently. The abstraction synthesis guarantees coverage and transition consistency per specified local error constraints. This is achieved via explicit resolution functions in the bisimulation relation or adaptive mesh design.

By focusing refinement on regions where the abstraction fails to meet specification (such as via counterexample analysis), MRASP frameworks markedly reduce model size and computation. In high-dimensional settings, such as embedded optimization (Donat et al., 2022) or complex dynamical systems (Weber et al., 2017), multilevel and mesh-based approaches mitigate the curse of dimensionality.

Termination of synthesis procedures is established for certain classes (e.g., δ-UB systems), and the approach is shown to generalize to cases beyond uniform stability assumptions. SMT-based refinement loops remain the principal runtime bottleneck, but modular and parallel learner-verifier architectures hint at further scalability.

6. Extensions, Limitations, and Research Directions

MRASP techniques support extensibility to non-deterministic, stochastic, and partially observed systems, as well as program domains with intricate semantic requirements (e.g., pointer aliasing or non-Boolean data). This suggests applicability in autonomous robotics, cyber-physical systems, safety-critical software analysis, and high-dimensional theoretical modeling.

A plausible implication is that further research will focus on parallelized synthesis (to reduce verification bottlenecks), automatic abstraction template selection, and integration of MRASP methodologies into cross-domain toolchains. While concrete limitations remain—such as inability to guarantee termination for all classes, and computational costs of verification—the frameworks advanced in recent literature provide robust platforms for further development and real-world application.

Table: Comparison of MRASP Approaches

Approach	Resolution Control	Verification Guarantee
Multi-resolution bisimulation (Coppola et al., 22 Sep 2025)	State-dependent (local $\epsilon$)	Soundness for δ-UB systems, compactness
Predicate abstraction (Fu et al., 2014)	Predicate refinement, sensor adaptation	Soundness through CEGAR loop
Mesh-optimized grids (Weber et al., 2017)	Hyperspace aspect ratio optimization	Predictable computational effort
BMDP abstraction (Dutreix et al., 2020)	Interval probabilities, partition refinement	Metric-based suboptimality, iterative refinement

In summary, the MRASP unifies a body of research aimed at synthesizing tractable abstractions meeting specified fidelity and error requirements. Its principal contributions include flexible error control, automated scalable synthesis, deep integration of counterexample-guided refinement, and broad applicability across verification, control, and synthesis domains.