[Paper Review] Complexity of Monadic inf-datalog. Application to temporal logic

Eugénie Foustoucos, Irène Guessarian|arXiv (Cornell University)|Mar 30, 2006

Formal Methods in Verification8 references3 citations

TL;DR

This paper presents a polynomial-time algorithm for evaluating Monadic inf-Datalog programs on finite models, establishing linear-space and linear-time complexity for stratified programs. It provides a unified proof of linear data and program complexity for CTL and alternation-free $μ$-calculus model checking, and polynomial-time data complexity with linear space for $L\mu_k$ (Modal $μ$-calculus with bounded alternation depth).

ABSTRACT

In [11] we defined Inf-Datalog and characterized the fragments of Monadic inf-Datalog that have the same expressive power as Modal Logic (resp. $CTL$, alternation-free Modal $μ$-calculus and Modal $μ$-calculus). We study here the time and space complexity of evaluation of Monadic inf-Datalog programs on finite models. We deduce a new unified proof that model checking has 1. linear data and program complexities (both in time and space) for $CTL$ and alternation-free Modal $μ$-calculus, and 2. linear-space (data and program) complexities, linear-time program complexity and polynomial-time data complexity for $Lμ\_k$ (Modal $μ$-calculus with fixed alternation-depth at most $k$).}

Motivation & Objective

• To analyze the time and space complexity of evaluating Monadic inf-Datalog programs on finite models.
• To provide a unified complexity proof for model checking in temporal logics like CTL and the alternation-free $μ$-calculus.
• To extend complexity bounds to $L\mu_k$, the Modal $μ$-calculus with bounded alternation depth.
• To bridge database query evaluation and temporal logic model checking via Datalog-based translations.
• To emphasize space complexity, which is less studied than time complexity in model checking.

Proposed method

• Designs an algorithm that evaluates Monadic inf-Datalog programs using a stratified evaluation order, processing least and greatest fixed points in sequence.
• Applies iterative fixed-point computation with a depth-first traversal strategy to handle mutual recursion between tagged (greatest) and untagged (least) IDB predicates.
• Uses a recursive evaluation framework where each stratum is processed in order, with intermediate results stored in arrays indexed by IDB symbols.
• Translates temporal logic formulas (e.g., CTL, $μ$-calculus) into Monadic inf-Datalog programs via known translations from prior work.
• Analyzes complexity by bounding the number of iterations per stratum, showing $O((n+1)^k \times I)$ time complexity, where $n$ is data size, $k$ is alternation depth, and $I$ is number of IDBs.
• Establishes that space complexity is linear in $n \times I$ by storing only current and previous fixed-point approximations.

Experimental results

Research questions

• RQ1 What is the time and space complexity of evaluating Monadic inf-Datalog programs on finite models?
• RQ2 Can a single algorithm unify complexity bounds for model checking in CTL, alternation-free $μ$-calculus, and $L\mu_k$?
• RQ3 How does the presence of alternations between least and greatest fixed points affect complexity?
• RQ4 What is the relationship between the structure of the Datalog program and the complexity of model checking in temporal logics?
• RQ5 Can space complexity be bounded linearly in data and program size, even for non-stratified or recursive programs?

Key findings

• The evaluation of stratified Monadic inf-Datalog programs runs in time $O(n \times I)$ and space $O(n \times I)$, where $n$ is the size of the database and $I$ the number of IDB predicates.
• For $L\mu_k$, the data complexity is polynomial-time $O((n+1)^k \times I)$, and space complexity is linear in $n \times I$, with linear-time program complexity.
• Model checking for CTL and alternation-free $μ$-calculus has linear data and program complexity in both time and space.
• The algorithm achieves linear space complexity even for programs with mutual recursion between least and greatest fixed points, provided they are stratified.
• The space complexity of the algorithm remains linear, while improved time bounds in prior work may incur exponential space, making this approach more practical for large models.
• The results provide a new, unified proof of known complexity bounds for temporal logic model checking, emphasizing space efficiency.