Schedule-Abstraction Graph (SAG) Framework

• Schedule-Abstraction Graph (SAG) is a graph-based formalism that models scheduling constraints and executions as DAGs, unifying domains from program verification to real-time analysis.
• The framework employs systematic abstraction and eligibility-driven expansion, using methods like SAT-based refinement to ensure sound, complete, and empirically efficient analysis.
• SAG achieves significant empirical gains in verification, schedulability analysis, and planning, and it supports domain-specific extensions with rigorous theoretical guarantees.

A Schedule-Abstraction Graph (SAG) is a precise, graph-theoretic formalism for representing scheduling constraints and execution scenarios in concurrent and real-time systems. SAG unifies several domains—model checking of multi-threaded programs, real-time schedulability analysis, parallel planning, and response-time bounds—by capturing all relevant interdependences among tasks, jobs, events, and resources in a directed acyclic graph (DAG). The framework enables sound, complete, and empirically efficient analysis across diverse applications, notably programming language verification, systems scheduling, automated agent planning, and hybrid-triggered real-time systems.

1. Core Definitions and Mathematical Structure

SAG is fundamentally a directed acyclic graph $G=(V,E)$, where each vertex encodes a system state, job, event, or subtask, and each edge represents a valid transition, resource dependency, or precedence. Formulations vary by domain:

• Multi-threaded program verification: Vertices correspond to execution events (reads, writes); $E$ encodes both program order and read-from relations. Additional variables (guards, clocks) express conditional execution and order constraints (Yin et al., 2017).
• Real-time non-preemptive scheduling: Vertices are states summarizing completed jobs and timing intervals; edges are dispatches labeled by jobs, with eligibility determined by nuanced rules (work-conserving, non-work-conserving policies) (Vlk et al., 31 Oct 2024).
• Hybrid-triggered job response-time analysis: Vertices represent execution histories including potential job absences, with associated earliest/latest finish time intervals; edges branch on both execution and absence (Cao et al., 22 Nov 2025).
• Parallel agent planning: Vertices denote fine-grained subtasks (rules); edges enforce dependency prerequisites. Each vertex may annotate execution time and cost (Zhang et al., 20 Feb 2025).

Table: SAG vertex semantics in key domains

Domain	Vertex content	Edge interpretation
Program verification	Events + guards/clocks	Program order, read-from links
Non-preemptive RTA	State: jobs done + time interval	Dispatching eligible jobs
Hybrid-triggered RTA	State: jobs/absences + intervals	Execution/absence branching
Parallel planning	Subtask/rule properties	Dependency constraints

2. Construction Algorithms and Eligibility Rules

Construction of the SAG proceeds by systematic expansion from an initial state (or event set):

• Abstraction/refinement in verification: Begin with a coarse abstraction ignoring global scheduling constraints ($\xi$). Candidate counterexamples are extracted via SAT solving; graph-based closure and constraint-based validation determine feasibility (Yin et al., 2017).
• Eligibility-driven expansion in scheduling: Each graph vertex stores the set of finished jobs and an interval $[eft(v),lft(v)]$ specifying when the processor is free. For each time point and job, eligibility rules are applied:
  • Work-conserving: Only certainly-eligible jobs or those possibly-eligible due to future releases are expanded.
  • Non-work-conserving: Incorporate critical windows forbidding dispatches that would interfere with critical tasks (Vlk et al., 31 Oct 2024).
• Hybrid-triggered modeling: Branches account for both execution and explicit absence ($C_i=0$), enabling tight coverage over all possible scenarios (Cao et al., 22 Nov 2025).
• Synthetic graph generation for planning: Automated DAG synthesis parameterizes structure, breadth, depth, and resource labels, feeding large corpora for model training (Zhang et al., 20 Feb 2025).

These procedures often employ substantial state/vertex merging to combat exponential blowup; identical job histories and overlapping intervals are coalesced.

3. Analytical Techniques and Inference Procedures

SAG-based analysis relies on reachability, closure, and kernel-reason tracing to infer global properties:

• Bounded model checking: After abstract counterexample extraction, SAG-based graph-closure incorporates derived order and "no-intervening" rules. Cyclic closure signals infeasibility, otherwise constraint-based SAT/SMT validating is invoked (Yin et al., 2017).
• Schedulability analysis: Reachability of vertices with $lft(v)>J.d$ directly signals a deadline miss; completion without encountering such vertices demonstrates system schedulability (Vlk et al., 31 Oct 2024). Sustainability follows from the monotonic shrinkage of intervals under parameter tightening.
• Exact hybrid RTA: Every possible release and execution scenario (including absences) is represented by root-to-leaf paths in the constructed SAG; earliest and latest response times for each job are obtained by path inspection (Cao et al., 22 Nov 2025).
• Plan optimization in agent scheduling: The global objective minimizes makespan and cost via dynamic programming; model training uses supervised fine-tuning and direct preference optimization (DPO) to shape agent outputs (Zhang et al., 20 Feb 2025).

4. Implementation and Empirical Evaluation

Domain-specific toolkits and systems implement the SAG framework:

• Yogar‐CBMC for program verification utilizes graph-based refinement, demonstrating a formula size $\frac{1}{8}$ that of the monolithic exact constraint and up to 35× speedup over CBMC on SV-COMP benchmarks. Graph-based counterexample validation caught 99.9% of infeasible cases (Yin et al., 2017).
• SGA-ME for non-preemptive analysis: Multiple eligibility checks yield a 17× speedup over single-eligibility expansion (SGA-SE), exact schedulability under critical window policies, and graceful scaling to hundreds of jobs (Vlk et al., 31 Oct 2024).
• SAGkit (Python): Hybrid SAG construction for distributed control systems, achieving exact response-time bounds across scenario spaces; overheads for 1,000-job sets remain tractable (construction time $\approx$ 182 s, worst-case $\leq$ 5.4× original), and vertex inflation is limited ($\leq$ 1.69×). Coverage metrics show original SAG severely under-approximates, extended does so overly pessimistically, while the hybrid construction is exact (Cao et al., 22 Nov 2025).
• Plan-over-Graph LLM pipeline: Two-stage training (SFT, DPO) on synthetic graphs leads to pronounced improvements in optimal planning metrics: e.g., for Llama-3.1-8B, success rate increased from 52.3% to 83.6%, optimal plan rate from 1.8% to 71.6% (Zhang et al., 20 Feb 2025).

5. Theoretical Guarantees

SAG frameworks rigorously document soundness, completeness, and sustainability:

• Soundness and completeness: Each refinement step or eligibility rule only prunes infeasible traces, maintaining over-approximation; termination follows from finite scenario enumeration (Yin et al., 2017, Vlk et al., 31 Oct 2024, Cao et al., 22 Nov 2025).
• Exact scenario coverage: Hybrid SAG constructions in SAGkit model every admissible execution pattern; extracted response bounds are tight (Cao et al., 22 Nov 2025).
• Sustainability: Any schedulable system remains so under reduced jitter or execution time, via monotonic interval shrinkage (Vlk et al., 31 Oct 2024).
• Generalization: SAG methods port to weak-memory models by extending edge and order rules; hybrid abstraction combines predicate and schedule-based reasoning; "plan-over-graph" paradigm admits prompt-centric planning with detachable graph-capable agents (Yin et al., 2017, Zhang et al., 20 Feb 2025).

6. Domain-Specific Extensions and Guidelines

The SAG abstraction admits extensions and practical customization:

• Predicate abstraction: For data-heavy concurrent programs, SAG may serve as a component in two-layer counterexample-guided abstraction refinement (CEGAR) (Yin et al., 2017).
• Hybrid-triggered jobs: Exact RTA is enabled by explicit modeling of job absence; only one discrete non-consecutive execution gap is supported in current SAGkit, with further extensions pending (Cao et al., 22 Nov 2025).
• Parallel schedules in intelligent agents: Synthetic DAGs and preference learning are crucial for scaling LLM comprehension. Separation of concerns (decomposition vs. scheduling) and prompt-centric design facilitate modularity and portability (Zhang et al., 20 Feb 2025).
• Scheduling policy selection: Critical window rules consistently yield higher schedulability at modest cost compared to EDF; merged graph construction prunes infeasibility efficiently (Vlk et al., 31 Oct 2024).

Practical guidelines recommend careful parameter tuning (e.g., tight jitter bounds, adjusted HT ratio), selection of scheduler policy, and use of visualization/debugging utilities for in-depth analysis (Cao et al., 22 Nov 2025).

7. Impact and Future Directions

The Schedule-Abstraction Graph framework has demonstrated order-of-magnitude empirical gains in verification, real-time analysis, and scalable planning. Its generality and flexibility position SAG as a universal backend for stateless analysis, distributed control timing, and concurrent agent scheduling. Prospects include extension to multiprocessor, preemptive domains, additional absence/event models, and integration with deep learning graph adapters. Limitations currently include exponential worst-case scaling and constrained support for self-suspensions or chained dependencies, but ongoing research focuses on systemic pruning and broader applicability. The ability to synthesize, analyze, and optimize schedule-constrained systems at scale marks SAG as a foundational tool in concurrent and real-time computation.