367,036 research outputs found
Two-Variable Logic with Two Order Relations
It is shown that the finite satisfiability problem for two-variable logic
over structures with one total preorder relation, its induced successor
relation, one linear order relation and some further unary relations is
EXPSPACE-complete. Actually, EXPSPACE-completeness already holds for structures
that do not include the induced successor relation. As a special case, the
EXPSPACE upper bound applies to two-variable logic over structures with two
linear orders. A further consequence is that satisfiability of two-variable
logic over data words with a linear order on positions and a linear order and
successor relation on the data is decidable in EXPSPACE. As a complementing
result, it is shown that over structures with two total preorder relations as
well as over structures with one total preorder and two linear order relations,
the finite satisfiability problem for two-variable logic is undecidable
Feasible Automata for Two-Variable Logic with Successor on Data Words
We introduce an automata model for data words, that is words that carry at
each position a symbol from a finite alphabet and a value from an unbounded
data domain. The model is (semantically) a restriction of data automata,
introduced by Bojanczyk, et. al. in 2006, therefore it is called weak data
automata. It is strictly less expressive than data automata and the expressive
power is incomparable with register automata. The expressive power of weak data
automata corresponds exactly to existential monadic second order logic with
successor +1 and data value equality \sim, EMSO2(+1,\sim). It follows from
previous work, David, et. al. in 2010, that the nonemptiness problem for weak
data automata can be decided in 2-NEXPTIME. Furthermore, we study weak B\"uchi
automata on data omega-strings. They can be characterized by the extension of
EMSO2(+1,\sim) with existential quantifiers for infinite sets. Finally, the
same complexity bound for its nonemptiness problem is established by a
nondeterministic polynomial time reduction to the nonemptiness problem of weak
data automata.Comment: 21 page
First-Order and Temporal Logics for Nested Words
Nested words are a structured model of execution paths in procedural
programs, reflecting their call and return nesting structure. Finite nested
words also capture the structure of parse trees and other tree-structured data,
such as XML. We provide new temporal logics for finite and infinite nested
words, which are natural extensions of LTL, and prove that these logics are
first-order expressively-complete. One of them is based on adding a "within"
modality, evaluating a formula on a subword, to a logic CaRet previously
studied in the context of verifying properties of recursive state machines
(RSMs). The other logic, NWTL, is based on the notion of a summary path that
uses both the linear and nesting structures. For NWTL we show that
satisfiability is EXPTIME-complete, and that model-checking can be done in time
polynomial in the size of the RSM model and exponential in the size of the NWTL
formula (and is also EXPTIME-complete). Finally, we prove that first-order
logic over nested words has the three-variable property, and we present a
temporal logic for nested words which is complete for the two-variable fragment
of first-order.Comment: revised and corrected version of Mar 03, 201
Path Checking for MTL and TPTL over Data Words
Metric temporal logic (MTL) and timed propositional temporal logic (TPTL) are
quantitative extensions of linear temporal logic, which are prominent and
widely used in the verification of real-timed systems. It was recently shown
that the path checking problem for MTL, when evaluated over finite timed words,
is in the parallel complexity class NC. In this paper, we derive precise
complexity results for the path-checking problem for MTL and TPTL when
evaluated over infinite data words over the non-negative integers. Such words
may be seen as the behaviours of one-counter machines. For this setting, we
give a complete analysis of the complexity of the path-checking problem
depending on the number of register variables and the encoding of constraint
numbers (unary or binary). As the two main results, we prove that the
path-checking problem for MTL is P-complete, whereas the path-checking problem
for TPTL is PSPACE-complete. The results yield the precise complexity of model
checking deterministic one-counter machines against formulae of MTL and TPTL
An automaton over data words that captures EMSO logic
We develop a general framework for the specification and implementation of
systems whose executions are words, or partial orders, over an infinite
alphabet. As a model of an implementation, we introduce class register
automata, a one-way automata model over words with multiple data values. Our
model combines register automata and class memory automata. It has natural
interpretations. In particular, it captures communicating automata with an
unbounded number of processes, whose semantics can be described as a set of
(dynamic) message sequence charts. On the specification side, we provide a
local existential monadic second-order logic that does not impose any
restriction on the number of variables. We study the realizability problem and
show that every formula from that logic can be effectively, and in elementary
time, translated into an equivalent class register automaton
Recommended from our members
Transformation of propositional calculus statements into integer and mixed integer programs: An approach towards automatic reformulation
A systematic procedure for transforming a set of logical statements or logical conditions imposed on a model into an Integer Linear Progamming (ILP) formulation Mixed Integer Programming (MIP) formulation is presented. An ILP stated as a system of linear constraints involving integer variables and an objective function, provides a powerful representation of decision problems through a tightly interrelated closed system of choices. It supports direct representation of logical (Boolean or prepositional calculus) expressions. Binary variables (hereafter called logical variables) are first introduced and methods of logically connecting these to other variables are then presented. Simple constraints can be combined to construct logical relationships and the methods of formulating these are discussed. A reformulation procedure which uses the extended reverse polish representation of a compound logical form is then described. These reformulation procedures are illustrated by two examples. A scheme of implementation.ithin an LP modelling system is outlined
- …