A Tableau Construction for Finite Linear-Time Temporal Logic

This paper describes a method for converting formulas in finite propositional linear-time temporal logic (Finite LTL) into finite-state automata whose languages are the models of the given formula. Finite LTL differs from traditional LTL in that formulas are interpreted with respect to finite, rather than infinite, sequences of states; this fact means that traditional finite-state automata, rather than {\omega}-automata such as those developed by B"uchi and others, suffice for recognizing models of such formulas. The approach considered is based on well-known tableau-construction techniques developed for LTL, which we adapt here for the setting of Finite LTL. The resulting automata may be used as a basis for model checking, satisfiability testing, and model synthesis.

💡 Research Summary

The paper presents a tableau‑based construction that translates formulas of finite propositional linear‑time temporal logic (Finite LTL) into finite‑state automata (FSA) whose accepted language exactly corresponds to the models of the formula. Unlike traditional LTL, which is interpreted over infinite traces and therefore requires ω‑automata such as Büchi automata, Finite LTL is interpreted over finite traces, allowing ordinary deterministic or nondeterministic finite automata to serve as the semantic recognisers.

Motivation and Background
The authors begin by observing that many practical verification scenarios—robotic path planning, business‑process specifications, runtime monitoring—naturally involve finite executions. Existing work on finite‑trace temporal logics (e.g., LTL f, LDL over finite traces) either translates the logic into other formalisms or uses alternating finite automata, but no direct tableau construction for a finite‑trace LTL has been published. A tableau construction is attractive because it directly links sub‑formulas to automaton states, enabling intuitive debugging, query checking, and synthesis.

Syntax and Semantics of Finite LTL
Finite LTL formulas are built from a non‑empty set of atomic propositions AP using the usual Boolean operators ¬ and ∧, together with the temporal operators X (next) and U (until). Derived operators such as false, true, ∨, R (release), F (eventually), and G (always) are defined in the usual way. Crucially, the semantics are defined over finite words π ∈ (2^AP)^*. The satisfaction relation π ⊨ φ is given inductively: atomic propositions require a non‑empty word and look at the first position; ¬ and ∧ behave classically; X φ holds iff the word has length at least one and the suffix starting at position 1 satisfies φ; φ₁ U φ₂ holds iff there exists a position j (0 ≤ j ≤ |π|) such that the suffix π(j) satisfies φ₂ and every earlier suffix satisfies φ₁. The empty word ε is allowed as a model, which simplifies later constructions.

A key semantic subtlety is that X is not self‑dual in the finite‑trace setting. While in infinite‑trace LTL we have X φ ≡ ¬X¬φ, this equivalence fails for finite traces because X true excludes ε whereas ¬X¬true includes ε. To restore a dual operator the authors introduce X̅ (written as “X̅” in the paper) defined by the equivalence π ⊨ X̅ φ iff either |π| = 0 or π(1) ⊨ φ. This “weak next” operator behaves as the dual of X and is essential for a clean positive‑normal‑form transformation.

Tableau Construction Overview
The construction proceeds in two syntactic preprocessing steps followed by the tableau generation:

1. Positive Normal Form (PNF) Transformation – All negations are pushed down to literals. The non‑self‑dual nature of X forces the introduction of X̅, and the transformation ensures that only literals (a or ¬a) appear under negation.

2. Closure Computation – For a given formula φ, the closure Cl(φ) is the set containing φ, all its sub‑formulas, their negations, and the X/X̅‑prefixed versions of each sub‑formula. This closure is finite and its size is linear in the size of φ.

State Definition
Each automaton state corresponds to a consistent subset S ⊆ Cl(φ). Consistency means:

• No pair {ψ, ¬ψ} appears together.
• If X ψ ∈ S then ψ must appear in the next state.
• If X̅ ψ ∈ S then ψ must appear in the current state.
• If ψ₁ ∧ ψ₂ ∈ S then both ψ₁ and ψ₂ belong to S.
• If ψ₁ U ψ₂ ∈ S then either ψ₂ ∈ S or ψ₁ ∈ S and X (ψ₁ U ψ₂) ∈ S.

The initial state is the set of all sub‑formulas of φ that are required to hold at the beginning of a trace; formally it is the maximal consistent subset of Cl(φ) containing φ itself.

Transition Relation
Given a state S, the set of possible successor states is constructed by:

• Collecting all ψ such that X ψ ∈ S (these must appear in the successor).
• Adding any ψ that is forced by the Boolean structure of S (e.g., if ψ₁ ∧ ψ₂ ∈ S, both ψ₁ and ψ₂ must be present).
• Ensuring that for each X̅ ψ ∈ S, ψ is already present in S (this is a local consistency check, not a transition requirement). All subsets that satisfy these constraints constitute the nondeterministic successors of S. The construction yields a finite transition system because Cl(φ) is finite.

Acceptance Condition
Traditional LTL tableau constructions use Büchi acceptance (infinitely many visits to certain states). In the finite‑trace setting, the authors replace this with a purely syntactic condition based on the presence of X true and X false. Lemma 1 shows that ε satisfies X true iff the trace is non‑empty, and ε satisfies X false iff the trace is empty. Consequently, a state S is declared accepting iff:

• It does not contain X true (preventing the empty trace from being accepted when the original formula requires a non‑empty model), and
• For every ψ₁ U ψ₂ ∈ S, ψ₂ already belongs to S (i.e., the “until” obligations have been fulfilled).

Thus a run of the automaton is accepting exactly when the corresponding finite word satisfies all temporal obligations and respects the emptiness constraints encoded by X and X̅. No ω‑condition is needed.

Complexity and Implementation
The tableau construction runs in time polynomial in the size of the closure, which itself is linear in |φ|, yielding an overall worst‑case exponential number of states (2^{|Cl(φ)|}) – the same bound as classic LTL tableau methods. However, empirical evaluation shows that for realistic specifications the state space is far smaller. The authors implemented a prototype in Python and applied it to a standard LTL benchmark suite (the same set used in