Periodizing ATR by Cho & Barnett

• The paper presents an ATR heuristic that dynamically allocates symbolic and concrete queries to balance over-approximation error with computational budget.
• The methodology adaptively refines temporal resolution by incrementally increasing symbolic query depths during the search phase until the budget is exhausted.
• Empirical results show significant runtime reductions and improved error metrics in high-dimensional control benchmarks compared to hand-tuned approaches.

Adaptive Temporal Refinement (ATR) refers to a family of methodologies that dynamically allocate computational or modeling resources along the time axis of a problem to optimize accuracy, efficiency, or both. ATR schemes strategically refine temporal resolution—by selecting time step sizes, increasing model complexity over time, or interleaving different levels of temporal abstraction—wherever dictated by problem structure, error estimators, or budget constraints. This encyclopedic entry focuses on the Periodizing Scheme introduced by Cho and Barnett (Sidrane et al., 19 Jul 2024), which formalizes ATR for discrete-time reachable set computation, providing automatic, budget-aware placement of "symbolic" versus "concrete" queries, and relates it to other influential ATR schemes across scientific computation and control.

1. Reachability Problems and Motivation for Temporal Refinement

Control systems analysis often requires computation of the forward reachable set for a nonlinear, possibly neural-network-controlled discrete-time system: $x_{t+1} = f(x_t, u_t), \quad u_t = c(x_t)$ with $x_t \in \mathbb{R}^d$, $u_t \in \mathbb{R}^m$, initial set $X_0 \subset \mathbb{R}^d$, and a finite horizon $n$. The objective is to over-approximate the $t$-step reachable sets $R_t$ as tightly as possible under computational constraints.

Traditional approaches leverage spatial refinement (partitioning the state or input space), but temporal allocation—dynamically deciding when in the time domain to invest more computational effort—remains underexplored. ATR, as formalized by Cho and Barnett, addresses this gap by automatically balancing approximation tightness (error) and computational tractability through temporal refinement.

2. Formalization: The ATR Heuristic and Error-Cost Tradeoff

ATR alternates between two modes:

• Symbolic queries: Long-horizon, computationally expensive reachable set computations resulting in low over-approximation error.
• Concrete queries: Single- or short-step, computationally cheap queries with higher over-approximation error.

The total approximation error aggregated over the horizon is: $$e = \frac{\sum_{t=1}^n m(\tilde{R}_t)}{\sum_{t=1}^n m(R_t)}$$ where $m(\cdot)$ quantifies set size (Lebesgue volume or hyperrectangle radius sum).

The time-budget model provides an online estimate $\tau_\text{est}$ of the per-step cost for symbolic refinement, adjusted after each successful symbolic query. The ATR criterion (Eq. 2) maintains $n \cdot \tau_\text{est} \leq b_\text{rem}$ during the search phase, predicting whether subsequent increased symbolic depths remain within budget. The scheme proceeds as follows:

1. Search phase: Incrementally attempt longer symbolic queries, updating $\tau_\text{est}$. If time remains, increase depth; else, transition to the jump phase.
2. Jump phase: Use the last safe symbolic depth repeatedly until the horizon is covered, reverting to shorter jumps if timeouts or overrun are detected.

ATR is agnostic to the particular structure of reachability solvers and over-approximation representations and is compatible with templates (zonotopes, polytopes), domain decomposition, or bound-propagation methods.

3. Algorithmic Structure and Pseudocode

The ATR logic can be distilled into two core routines, which determine symbolic depth at each step and manage control flow. Pseudocode outlining the periodizing ATR is:

function RefinedReach(q, X₀, b) timeout ← b; phase ← "search"; b_steps ← 1 t_start ← 0; t_cur ← 0; X_start ← X₀; Ṙ_list ← [] while t_cur < n do q.horizon ← b_steps (data, Ṙ_out) ← SymbolicReach(q, X_start) if phase == "search" append Ṙ_list with Ṙ_out[end] else append Ṙ_list with all Ṙ_out end t_cur ← t_start + b_steps b_rem ← b − elapsed_time() (b_steps, phase) ← calc_steps(t_start, b_steps, b_rem, data, Ṙ_list, n, phase, q.status) if phase == "jump" t_start ← t_cur X_start ← Ṙ_list[t_start] end b_steps ← min(b_steps, n-t_start) update_timeout!(q, b_rem) end return Ṙ_list end

The $\text{calc\_steps}$ function adjusts $b_\text{steps}$ (temporal depth) adaptively by comparing the time estimate for $n$ steps to remaining budget and responds to timeouts. Concrete implementations require robust early-stop conditions and careful budget accounting.

4. Integration with Spatial/Domain Refinement and Generalization

ATR is fully orthogonal to spatial or domain refinement. It can wrap any reachability backend, including:

• Domain decomposition or domain splitting,
• Subsystem decomposition (decoupling dynamics),
• Template-based overapproximation (e.g., via zonotopes, ellipsoids, polytopes),
• Mixed-integer programming (MILP/SMT-based symbolic reach),
• PDE-based overapproximations (HJ-reachability).

ATR thus enables a multi-dimensional refinement scheme in which both the spatial and temporal indices are automatically adapted, and temporal subproblem size is allocated as needed per the evolving computational budget.

5. Theoretical Properties: Soundness, Completeness, Complexity

• Soundness: Each reachability computation (symbolic or concrete) is an over-approximation, so $R_t \subseteq \tilde{R}_t$ for all $t$. The composed ATR output maintains conservativeness.
• Completeness: Not guaranteed, since ATR is a heuristic focused on the error–compute tradeoff. Embedding within a convergence-guaranteed spatial refinement (e.g., via successive underdiscretization) can restore completeness.
• Complexity: Underlying MILP/SMT subproblems remain NP-hard. Empirically, average solve times for symbolic depths scale linearly in depth, justifying linearity assumptions in budget estimation. Worst-case remains exponential in dynamic complexity.

6. Empirical Performance and Comparative Results

ATR demonstrates marked empirical gains over hand-tuned and naive approaches in neural-feedback benchmarks for nonlinear systems (pendulum, TORA, car):

Task	ATR Error (e₍vol₎/e₍rad₎)	ATR Time (s)	Hand-tuned Baseline Error	Hand-tuned Time (s)
S1	1.94 / 1.59	15.3	2.27 / 1.61	19.3
T1	Comparable	47.8	Comparable	63.0

In higher-dimensional car benchmarks, ATR achieves 65–71% runtime reduction at equal or better error metrics (C1: 117 s vs. 400 s, C2: 131 s vs. 378 s).

Performance curves show non-monotonic improvement in error as a function of computational budget due to adaptive depth selection, but the overall trend is superior to static hybrid strategies.

7. Implementation Considerations and Practical Notes

ATR's time estimates ($\tau_\text{est}$) serve as heuristics; actual symbolic query times may exceed or fall short, so robust early-stop and fallback mechanisms are essential. Timeouts should be configured to allow small duality gaps in MILP if necessary.

The initial search phase is critical for managing "wrapping effects"—errors accruing from early over-approximations—thus reducing cumulative error propagation.

ATR has been implemented in the Julia library OVERTVerify.jl, interfacing with generic symbolic reachability solvers. Its agnosticism to the spatial over-approximation backend allows broad applicability and easy integration into existing formal verification pipelines.

---

In summary, the periodizing scheme by Cho and Barnett establishes a principled, computationally efficient framework for adaptive temporal refinement in discrete-time reachable set computation. It is characterized by automatic, error–budget-aware allocation of symbolic versus concrete queries, robust orthogonality to spatial refinement, empirical tightness improvements in reachable-set estimation, and open-source implementation for reproducibility (Sidrane et al., 19 Jul 2024).