2,838 research outputs found
Nominal Regular Expressions for Languages over Infinite Alphabets
We propose regular expressions to abstractly model and study properties of resource-aware computations. Inspired by nominal techniques – as those popular in process calculi – we extend classical regular expressions with names (to model computational resources) and suitable operators (for allocation, deallocation, scoping of, and freshness conditions on resources). We discuss classes of such nominal regular expressions, show how such expressions have natural interpretations in terms of languages over infinite alphabets, and give Kleene theorems to characterise their formal languages in terms of nominal automata
A Kleene Theorem for Nominal Automata
Nominal automata are a widely studied class of automata designed to recognise languages over infinite alphabets. In this paper, we present a Kleene theorem for nominal automata by providing a syntax to denote regular nominal languages. We use regular expressions with explicit binders for creation and destruction of names and pinpoint an exact property of these expressions - namely memory-finiteness - identifying a subclass of expressions denoting exactly regular nominal languages
Towards Nominal Formal Languages
We introduce formal languages over infinite alphabets where words may contain
binders. We define the notions of nominal language, nominal monoid, and nominal
regular expressions. Moreover, we extend history-dependent automata
(HD-automata) by adding stack, and study the recognisability of nominal
languages
On the Structure and Complexity of Rational Sets of Regular Languages
In a recent thread of papers, we have introduced FQL, a precise specification
language for test coverage, and developed the test case generation engine
FShell for ANSI C. In essence, an FQL test specification amounts to a set of
regular languages, each of which has to be matched by at least one test
execution. To describe such sets of regular languages, the FQL semantics uses
an automata-theoretic concept known as rational sets of regular languages
(RSRLs). RSRLs are automata whose alphabet consists of regular expressions.
Thus, the language accepted by the automaton is a set of regular expressions.
In this paper, we study RSRLs from a theoretic point of view. More
specifically, we analyze RSRL closure properties under common set theoretic
operations, and the complexity of membership checking, i.e., whether a regular
language is an element of a RSRL. For all questions we investigate both the
general case and the case of finite sets of regular languages. Although a few
properties are left as open problems, the paper provides a systematic semantic
foundation for the test specification language FQL
Nesting Depth of Operators in Graph Database Queries: Expressiveness Vs. Evaluation Complexity
Designing query languages for graph structured data is an active field of
research, where expressiveness and efficient algorithms for query evaluation
are conflicting goals. To better handle dynamically changing data, recent work
has been done on designing query languages that can compare values stored in
the graph database, without hard coding the values in the query. The main idea
is to allow variables in the query and bind the variables to values when
evaluating the query. For query languages that bind variables only once, query
evaluation is usually NP-complete. There are query languages that allow binding
inside the scope of Kleene star operators, which can themselves be in the scope
of bindings and so on. Uncontrolled nesting of binding and iteration within one
another results in query evaluation being PSPACE-complete.
We define a way to syntactically control the nesting depth of iterated
bindings, and study how this affects expressiveness and efficiency of query
evaluation. The result is an infinite, syntactically defined hierarchy of
expressions. We prove that the corresponding language hierarchy is strict.
Given an expression in the hierarchy, we prove that it is undecidable to check
if there is a language equivalent expression at lower levels. We prove that
evaluating a query based on an expression at level i can be done in
in the polynomial time hierarchy. Satisfiability of quantified Boolean formulas
can be reduced to query evaluation; we study the relationship between
alternations in Boolean quantifiers and the depth of nesting of iterated
bindings.Comment: Improvements from ICALP 2016 review comment
- …