Separation of Test-Free Propositional Dynamic Logics over Context-Free Languages

📝 Abstract

For a class L of languages let PDL[L] be an extension of Propositional Dynamic Logic which allows programs to be in a language of L rather than just to be regular. If L contains a non-regular language, PDL[L] can express non-regular properties, in contrast to pure PDL. For regular, visibly pushdown and deterministic context-free languages, the separation of the respective PDLs can be proven by automata-theoretic techniques. However, these techniques introduce non-determinism on the automata side. As non-determinism is also the difference between DCFL and CFL, these techniques seem to be inappropriate to separate PDL[DCFL] from PDL[CFL]. Nevertheless, this separation is shown but for programs without test operators.

💡 Analysis

For a class L of languages let PDL[L] be an extension of Propositional Dynamic Logic which allows programs to be in a language of L rather than just to be regular. If L contains a non-regular language, PDL[L] can express non-regular properties, in contrast to pure PDL. For regular, visibly pushdown and deterministic context-free languages, the separation of the respective PDLs can be proven by automata-theoretic techniques. However, these techniques introduce non-determinism on the automata side. As non-determinism is also the difference between DCFL and CFL, these techniques seem to be inappropriate to separate PDL[DCFL] from PDL[CFL]. Nevertheless, this separation is shown but for programs without test operators.

📄 Content

Giovanna D’Agostino, Salvatore La Torre (Eds.): Proceedings of the Second International Symposium on “Games, Automata, Logics and Formal Verification” (GandALF 2011) EPTCS 54, 2011, pp. 207–221, doi:10.4204/EPTCS.54.15 c⃝Markus Latte This work is licensed under the Creative Commons Attribution-No Derivative Works License. Separation of Test-Free Propositional Dynamic Logics over Context-Free Languages Markus Latte∗ Department of Computer Science University of Munich, Germany For a class L of languages let PDL[L] be an extension of Propositional Dynamic Logic which allows programs to be in a language of L rather than just to be regular. If L contains a non-regular language, PDL[L] can express non-regular properties, in contrast to pure PDL. For regular, visibly pushdown and deterministic context-free languages, the separation of the respective PDLs can be proven by automata-theoretic techniques. However, these techniques introduce non-determinism on the automata side. As non-determinism is also the difference between DCFL and CFL, these techniques seem to be inappropriate to separate PDL[DCFL] from PDL[CFL]. Nevertheless, this separation is shown but for programs without test operators. 1 Introduction Propositional Dynamic Logic (PDL) [9] is a logical formalism to specify and verify programs [12, 16, 11]. These tasks rely on the satisfiability and model-checking problems. Applications in the field are supported by their relatively low complexities: EXPTIME- and PTIME-complete, respectively [9]. Formulas in PDL are interpreted over labeled transition systems. For instance, the formula ⟨p⟩ϕ means that after executing the program p the formula ϕ shall hold. In this context, programs and formulas are defined mutually inductively. This mixture allows programs to test whether or not a formula holds at the current state. Additionally, programs are required to be regular over the set of atomic programs and test operations. For instance, the program while (b) do p; can be rendered as ⟨(b?; p)∗;¬b⟩ϕ to ensure that the loop is finite and that ϕ holds when the loop terminates [9]. The small model property of PDL [9] cuts both ways. First, it admits a decision procedure for satisfiability, but secondly it restricts the expressivity to regular properties. As a consequence counting properties and, in particular, the nature of execution stacks cannot be expressed. The last consequence runs contrary to the verification of recursive programs. A natural way to enhance the expressivity is to relax the regularity requirement. For a class L of languages let PDL[L] denote the variation which requires that any program belongs to L1. For instance, we write a diamond as ⟨L⟩ϕ for L ∈L. This leads to a hierarchy of logics. Obviously, PDL[L] ≤PDL[M] holds for L ⊆M. Besides regular languages, we consider the variations for the class of visibly pushdown ∗Supported by the DFG Graduiertenkolleg 1480 (PUMA). 1 If test operations and deterministic languages are in involved, the test operations also must behave deterministically. In the case of DCFLs the additional restriction reads as follows (using the notation in [15]). • For any state q, at most one of δ(q,a,X) (for a ∈Σ), δ(q,ε,X) and δ(q,ϕ?,X) (for some PDL[L]-formula ϕ) is not empty. • For any state q and two distinct PDL[L]-formulas ϕ1 and ϕ2, we have that if δ(q,ϕ1?,X) ̸= /0 and δ(q,ϕ2?,X) ̸= /0 then ϕ1 and ϕ2 are semantically disjoint, that is |= ¬(ϕ1 ∧ϕ2). Otherwise, it would be possible to simulate a non-deterministic choice by inserting a test for “true” for every possible choice and vary each test syntactically in a different way. Note that “true” has infinitely many synonyms. A non-example is ∆PDL?[CFL] = ∆PDL?[DCFL] in [2]. 208 Separation of Test-Free Propositional Dynamic Logic over Context-Free Languages languages [1], VPL, the class of deterministic context-free languages, DCFL, and context-free languages, CFL. The inclusion order continues on the logics’ side. PDL = PDL[REG] ≤PDL[VPL] ≤PDL[DCFL] ≤PDL[CFL]. (1) Harel et al. discussed the effect of adding single (deterministic) context-free programs to PDL [13, 14, 12]. The logic PDL[VPL] were introduced by L¨oding et al. [17]. To handle the respective decision problems, the languages are represented by a machine model for the respective class. For each of these logics, any of its formula ϕ can be translated into an ω-tree-automaton which recognizes exactly all tree-like models of ϕ where the out-degree of any node is globally bounded. Such a model exists iff ϕ is satisfiable. For PDL and PDL[REG] these tree-automata are finite-state [23], for PDL[VPL] they are visibly pushdown tree-automata [14, 17] and for PDL[DCFL] and PDL[CFL] they are tree-automata with unbounded number of stacks. The last notion is rather artificial. However, the stacks are used, first, to accumulate unfulfilled eventualities and to simulate the complementation of programs given as pushdown automata. Note that in the setting of visibly pushdown automata, only one st

This content is AI-processed based on ArXiv data.