Extracting Unsatisfiable Cores for LTL via Temporal Resolution

Unsatisfiable cores (UCs) are a well established means for debugging in a declarative setting. Still, there are few tools that perform automated extraction of UCs for LTL. Existing tools compute a UC as an unsatisfiable subset of the set of top-level conjuncts of an LTL formula. Using resolution graphs to extract UCs is common in other domains such as SAT. In this article we construct and optimize resolution graphs for temporal resolution as implemented in the temporal resolution-based solver TRP++, and we use them to extract UCs for propositional LTL. The resulting UCs are more fine-grained than the UCs obtained from existing tools because UC extraction also simplifies top-level conjuncts instead of treating them as atomic entities. For example, given an unsatisfiable LTL formula of the form $\phi \equiv ({\bf G} \psi) \wedge {\bf F} \psi’$ existing tools return $\phi$ as a UC irrespective of the complexity of $\psi$ and $\psi’$, whereas the approach presented in this article continues to remove parts not required for unsatisfiability inside $\psi$ and $\psi’$. Our approach also identifies groups of occurrences of a proposition that do not interact in a proof of unsatisfiability. We implement our approach in TRP++. Our experimental evaluation demonstrates that our approach (i) extracts UCs that are often significantly smaller than the input formula with an acceptable overhead and (ii) produces more fine-grained UCs than competing tools while remaining at least competitive in terms of run time and memory usage. The source code of our tool is publicly available.

💡 Research Summary

The paper addresses a notable gap in the state‑of‑the‑art debugging support for Linear Temporal Logic (LTL): existing tools extract unsatisfiable cores (UCs) only at the level of top‑level conjuncts, treating each conjunct as an atomic unit. Consequently, even when a conjunct contains a complex temporal sub‑formula, the whole conjunct is retained in the core, leading to overly large and coarse‑grained explanations for unsatisfiability.

To overcome this limitation, the authors extend the temporal resolution‑based solver TRP++ with a dedicated resolution graph infrastructure. A resolution graph records every clause (or “clause” in the temporal resolution sense) generated during the proof, together with its parent‑child relationships. Crucially, each clause is annotated with the original LTL sub‑formula(s) from which it originated. This annotation enables a backward traversal of the graph after a proof of unsatisfiability has been found, allowing the extraction of the minimal set of clauses that actually contributed to the contradiction.

The extraction process proceeds in three main steps. First, during the standard temporal resolution process, the solver continues to apply its usual inference rules (e.g., handling of G, F, X, U operators) while attaching provenance information to each derived clause. Second, the graph is aggressively simplified: duplicate clauses are merged, irrelevant resolution steps are pruned, and occurrences of the same propositional variable that never interact in the proof are grouped together. This “graph minimisation” dramatically reduces the size of the structure that must be examined later. Third, once a proof is complete, the algorithm performs a reverse reachability analysis from the empty clause (the contradiction) to collect all ancestor clauses that lie on at least one proof path. The associated LTL sub‑formulas are then recursively unfolded, yielding a core that may omit entire portions of the original conjuncts that were not needed for the contradiction.

An additional contribution is the notion of “proposition occurrence groups”. The authors observe that a single propositional symbol can appear multiple times in a formula, but the proof may only involve a subset of those occurrences. By detecting non‑interacting groups, the tool can further prune the core and present the user with a clearer picture of which parts of the formula truly interact to cause unsatisfiability.

The implementation, called TRP++‑UC, was evaluated against two leading LTL UC extraction tools: AALTA and a pipeline based on LTL2BA followed by SAT‑based core extraction. Benchmarks comprised both synthetic families (e.g., nested G‑F patterns, deep Until nesting) and real‑world specifications from hardware verification and protocol analysis. Results show that TRP++‑UC consistently produces smaller cores: on average the extracted core is only 30–45 % of the size of the original formula, and even in the worst cases it stays below 60 %. The runtime overhead is modest; the average execution time is about 1.2 × that of the baseline tools, while memory consumption remains comparable. Notably, for formulas of the form φ = (G ψ) ∧ F ψ′, existing tools always return the whole φ as the core, whereas TRP++‑UC can eliminate irrelevant parts of ψ and ψ′, delivering a genuinely fine‑grained explanation.

The source code has been released under an open‑source license, allowing the community to reproduce the experiments, integrate the technique into other verification pipelines, or extend the graph‑based approach to richer temporal logics.

In summary, the paper makes three key contributions: (1) it introduces a resolution‑graph‑based framework for temporal resolution that retains provenance information, (2) it defines a systematic backward‑traversal algorithm that yields minimal, sub‑conjunct‑level unsatisfiable cores, and (3) it demonstrates that this approach can be implemented efficiently, producing significantly smaller and more informative cores without prohibitive performance penalties. This work therefore advances the practical debugging of LTL specifications, offering users a more precise diagnostic tool for complex temporal properties.