- The paper introduces a modular C++17 framework that combines SMT solvers, sequential analyzers, and parallel portfolio scheduling to prove lasso-program termination or non-termination.
- Evaluation on 4,619 lasso programs showed identical coverage to ULR, while P-ULR reduced total runtime by 862 seconds sequentially and achieved a 2.8× speedup over ULR-Baseline in four-thread mode.
- The framework remains limited to selected linear arithmetic domains and lacks full support for arrays, nonlinear formulas, and recurrence-set synthesis, while benchmark composition provided little additional benefit from parallelism.
Motivation and scope
Termination of programs is undecidable in general, but for lasso programs — a stem of straight-line code followed by a single while loop, typically extracted as candidate infinite traces during CEGAR-based liveness verification — both termination and non-termination admit decidable sufficient conditions. A linear ranking function certifies termination; a recurrence set or a geometric non-termination argument (GNTA) certifies non-termination. Because each certificate class is one-sided (failure to find one proves nothing), practical analyzers benefit from running heterogeneous strategies concurrently and returning whichever conclusive argument is found first. PaSTTeL addresses exactly this setting: it is a modular C++17 framework that unifies state-of-the-art constraint-based termination and non-termination techniques in a parallel portfolio, and is designed to be embedded as a self-contained library in external verification tools (2606.18977).
Architecture
The framework is organized around three components, each defined by an interface that any instantiation must implement:
- SMT engine (
SMTSolverInterface): pluggable solver backends; Z3 and cvc5 are currently supported. Each sequential analyzer receives its own solver instance.
- Sequential analyzer (
AnalysisInterface): an adapter exposing analyze(), which returns TERMINATING, NON_TERMINATING, or UNKNOWN, and getProof(), which returns a plain-text proof certificate.
- Parallelization layer (
PortfolioAnalyzer): registers arbitrary analyzers via addTechnique, launches them concurrently over the same input via solve(), and blocks in join(timelimit) until some strategy returns a conclusive result or the time limit expires.
An entry-point function, init-PaSTTeL, binds these components: given a linear lasso program (llp), a thread count, and a solver type, it creates the solvers, registers the strategies, runs the portfolio, and prints the result and proof if conclusive. This design makes new strategy integration a matter of implementing one adapter, and makes the whole framework embeddable without knowledge of its internals.
P-ULR: replicating Ultimate LassoRanker
To validate genericity, the authors implemented P-ULR, an instantiation reproducing the core strategies of Ultimate LassoRanker (ULR), the SV-COMP 2025 winner at the lasso level. P-ULR accepts a tool-agnostic JSON format with SMT-LIB-encoded formulas in SSA form, linearizes when necessary, and dispatches to registered analyzers:
- Termination: constraint-based synthesis using linear ranking templates (Leike, 2014), supporting affine and nested templates; adding lexicographic, multiphase, or piecewise templates reportedly requires only a few lines of C++.
- Non-termination: fixpoint checking and GNTA synthesis (Leike et al., 2016).
The authors are explicit about current limitations: array operations are not handled by the linearization step (supporting invariants for arrays would be needed); non-linear formulas are passed through unchanged, which is only sound for strategies such as fixpoint checking that tolerate them; termination synthesis is restricted to QF_LRA and GNTA to QF_LIA; and coefficient simplification and formula optimization are unimplemented. Extensions to QF_NRA/QF_NIA remain future work.
Experimental evaluation
The benchmark consists of 4619 lasso programs serialized from Ultimate BüchiAutomizer runs (600 s timeout) on SV-COMP 2025, TermCOMP 2025, and Boogie instances from the Ultimate repository. ULR's per-strategy solving times were logged into the lasso files, excluding JVM startup. Both tools used Z3.
| Tool |
#Terminating |
Time (s) |
#Non-Terminating |
Time (s) |
| ULR-Baseline |
3531 |
1309.64 |
1088 |
47.13 |
| P-ULR-Seq |
3531 |
492.61 |
1088 |
1.78 |
| P-ULR-Par4 |
3531 |
470.74 |
1088 |
1.62 |
Both tools solve identical instance sets, so the comparison isolates implementation efficiency rather than coverage. In sequential mode (P-ULR-Seq, same fixed strategy order as ULR-Baseline), P-ULR saves 862 s overall, and accumulated non-termination time drops by a factor of 26 (47.13 s → 1.78 s). Scatter plots attribute this to two regimes: on terminating instances, most solved by affine ranking functions, P-ULR-Seq is generally faster, though ULR's partitioning step yields simpler ranking functions with smaller coefficients and reduces ULR's time on some instances (points above the y=x diagonal); on non-terminating instances, fixpoint-based proofs show comparable times while GNTA proofs favor P-ULR-Seq markedly.
In parallel mode (P-ULR-Par4, four threads running fixpoint, GNTA, affine, and nested templates from 2-nested to 5-nested), total time improves by a factor of 2.8 over ULR-Baseline (a gain of 884.4 s), but only marginally over P-ULR-Seq. The authors explain this candidly: 98% of the benchmark's lasso programs admit affine ranking functions, which the sequential order already resolves first, so the benchmark composition leaves little room for parallelism to help. This is an important caveat — the headline speedup comes primarily from the native C++ implementation, not from the portfolio architecture, and the parallel advantage would only manifest on benchmarks with more diverse certificate requirements.
Limitations and open questions
Beyond the arithmetic-domain restrictions (QF_LRA for termination, QF_LIA for GNTA) and the incomplete handling of non-linear and array-bearing formulas noted above, three points bear directly on interpreting the results. First, the absence of ULR's partitioning step means P-ULR produces ranking functions with larger coefficients; whether this affects downstream consumers of certificates (e.g., proof checkers or witness validators) is not evaluated. Second, the near-absence of parallel speedup on this benchmark means the central design claim — that concurrent portfolios improve analysis throughput — is supported architecturally but not yet demonstrated empirically on certificate-diverse workloads. Third, recurrence set synthesis (Frohn et al., 2019) is identified as a planned additional non-termination strategy but is not yet integrated, so the portfolio's non-termination coverage matches rather than exceeds ULR's.
Conclusion
PaSTTeL contributes a clean separation of concerns — solver backend, sequential analyzer, portfolio scheduler — for combining termination and non-termination analyses of lasso programs, together with evidence that a faithful reimplementation of ULR's strategies in C++17 is substantially faster than the JVM-based original while solving exactly the same instances. The evaluation leaves open whether the parallel portfolio yields gains beyond implementation-level speedups on benchmarks where no single template dominates, and whether the framework's coverage can be extended to non-linear and array-manipulating loops without sacrificing its modularity.