scholarly journals Stratified Negation in Limit Datalog Programs

2018 ◽  
Author(s):  
Mark Kaminski ◽  
Bernardo Cuenca Grau ◽  
Egor V. Kostylev ◽  
Boris Motik ◽  
Ian Horrocks
Keyword(s):  
Data Analysis ◽  
Logic Programming ◽  
Arithmetic Function ◽  
Expressive Power ◽  
General Purpose ◽  
Data Complexity ◽  
Prior Work ◽  
Complexity Bounds ◽  
Logical Language ◽  
Query Engine

There has recently been an increasing interest in declarative data analysis, where analytic tasks are specified using a logical language, and their implementation and optimisation are delegated to a general-purpose query engine. Existing declarative languages for data analysis can be formalised as variants of logic programming equipped with arithmetic function symbols and/or aggregation, and are typically undecidable. In prior work, the language of limit programs was proposed, which is sufficiently powerful to capture many analysis tasks and has decidable entailment problem. Rules in this language, however, do not allow for negation. In this paper, we study an extension of limit programs with stratified negation-as-failure. We show that the additional expressive power makes reasoning computationally more demanding, and provide tight data complexity bounds. We also identify a fragment with tractable data complexity and sufficient expressivity to capture many relevant tasks.

scholarly journals DatalogMTL: Computational Complexity and Expressive Power

2019 ◽  
Author(s):  
Przemysław A. Wałęga ◽  
Bernardo Cuenca Grau ◽  
Mark Kaminski ◽  
Egor V. Kostylev
Keyword(s):  
Computational Complexity ◽  
Knowledge Representation ◽  
Data Access ◽  
Expressive Power ◽  
Data Complexity ◽  
Complexity Bounds ◽  
Metric Temporal Logic ◽  
Stream Reasoning ◽  
Knowledge Representation Language ◽  
Representation Language

We study the complexity and expressive power of DatalogMTL - a knowledge representation language that extends Datalog with operators from metric temporal logic (MTL) and which has found applications in ontology-based data access and stream reasoning. We establish tight PSpace data complexity bounds and also show that DatalogMTL extended with negation on input predicates can express all queries in PSpace; this implies that MTL operators add significant expressive power to Datalog. Furthermore, we provide tight combined complexity bounds for the forward-propagating fragment of DatalogMTL, which was proposed in the context of stream reasoning, and show that it is possible to express all PSpace queries in the fragment extended with the falsum predicate.

scholarly journals The Complexity and Expressive Power of Limit Datalog

2022 ◽  
Vol 69 (1) ◽  
pp. 1-83
Author(s):  
Mark Kaminski ◽  
Egor V. Kostylev ◽  
Bernardo Cuenca Grau ◽  
Boris Motik ◽  
Ian Horrocks
Keyword(s):  
Data Analysis ◽  
Expressive Power ◽  
Arithmetic Functions ◽  
Linear Programs ◽  
Data Complexity ◽  
Descriptive Complexity ◽  
Data Intensive ◽  
Additional Stability ◽  
Decidability And Complexity ◽  
The Impact

Motivated by applications in declarative data analysis, in this article, we study Datalog Z —an extension of Datalog with stratified negation and arithmetic functions over integers. This language is known to be undecidable, so we present the fragment of limit Datalog Z programs, which is powerful enough to naturally capture many important data analysis tasks. In limit Datalog Z , all intensional predicates with a numeric argument are limit predicates that keep maximal or minimal bounds on numeric values. We show that reasoning in limit Datalog Z is decidable if a linearity condition restricting the use of multiplication is satisfied. In particular, limit-linear Datalog Z is complete for Δ 2 EXP and captures Δ 2 P over ordered datasets in the sense of descriptive complexity. We also provide a comprehensive study of several fragments of limit-linear Datalog Z . We show that semi-positive limit-linear programs (i.e., programs where negation is allowed only in front of extensional atoms) capture coNP over ordered datasets; furthermore, reasoning becomes coNEXP-complete in combined and coNP-complete in data complexity, where the lower bounds hold already for negation-free programs. In order to satisfy the requirements of data-intensive applications, we also propose an additional stability requirement, which causes the complexity of reasoning to drop to EXP in combined and to P in data complexity, thus obtaining the same bounds as for usual Datalog. Finally, we compare our formalisms with the languages underpinning existing Datalog-based approaches for data analysis and show that core fragments of these languages can be encoded as limit programs; this allows us to transfer decidability and complexity upper bounds from limit programs to other formalisms. Therefore, our article provides a unified logical framework for declarative data analysis which can be used as a basis for understanding the impact on expressive power and computational complexity of the key constructs available in existing languages.

Microcomputers in Political Science

1983 ◽  
Vol 38 ◽  
pp. 1-9
Author(s):  
Herbert F. Weisberg
Keyword(s):  
Data Analysis ◽  
Political Science ◽  
Large Scale ◽  
Turnaround Time ◽  
General Purpose ◽  
Batch Mode ◽  
New Era ◽  
Large Scale Data ◽  
The Social ◽  
Frequency Counts

We are now entering a new era of computing in political science. The first era was marked by punched-card technology. Initially, the most sophisticated analyses possible were frequency counts and tables produced on a counter-sorter, a machine that specialized in chewing up data cards. By the early 1960s, batch processing on large mainframe computers became the predominant mode of data analysis, with turnaround time of up to a week. By the late 1960s, turnaround time was cut down to a matter of a few minutes and OSIRIS and then SPSS (and more recently SAS) were developed as general-purpose data analysis packages for the social sciences. Even today, use of these packages in batch mode remains one of the most efficient means of processing large-scale data analysis.

Logics for the Semantic Web

2011 ◽  
pp. 24-43
Author(s):  
J. Bruijn
Keyword(s):  
Semantic Web ◽  
Logic Programming ◽  
Description Logic ◽  
Description Logics ◽  
Order Logic ◽  
First Order Logic ◽  
Horn Logic ◽  
First Order ◽  
Logical Language ◽  
Rule Languages

This chapter introduces a number of formal logical languages which form the backbone of the Semantic Web. They are used for the representation of both ontologies and rules. The basis for all languages presented in this chapter is the classical first-order logic. Description logics is a family of languages which represent subsets of first-order logic. Expressive description logic languages form the basis for popular ontology languages on the Semantic Web. Logic programming is based on a subset of first-order logic, namely Horn logic, but uses a slightly different semantics and can be extended with non-monotonic negation. Many Semantic Web reasoners are based on logic programming principles and rule languages for the Semantic Web based on logic programming are an ongoing discussion. Frame Logic allows object-oriented style (frame-based) modeling in a logical language. RuleML is an XML-based syntax consisting of different sublanguages for the exchange of specifications in different logical languages over the Web.

DESIGN AND IMPLEMENTATION OF AN EDITOR/INTERPRETER FOR A VISUAL LOGIC PROGRAMMING LANGUAGE

2013 ◽  
Vol 23 (06) ◽  
pp. 801-838
Author(s):  
OMID BANYASAD ◽  
PHILIP T. COX
Keyword(s):  
User Interface ◽  
Logic Programming ◽  
Programming Language ◽  
Interface Design ◽  
General Purpose ◽  
Programming Environment ◽  
Design Decisions ◽  
Logic Programming Language ◽  
Design And Implementation ◽  
Visual Interface

The design and implementation of a programming environment including an editor, a debugger and an interpreter engine for Lograph, a general-purpose visual logic programming language, is discussed. The rationale for user-interface design decisions is presented, the goal of which is to increase cognitive support for the creation, exploration and debugging of Lograph programs. The design of the interpreter engine allows for animation of execution in the debugger. The engine takes full advantage of an efficient implementation of Prolog, and operates on a Prolog translation of Lograph programs and queries. The translated Lograph programs are probed with instrumentation code at appropriate places so that applications of Lograph rules are reported to the visual interface of the Lograph debugger as a side effect of the execution of a program.

Sign in / Sign up

Export Citation Format

Share Document