Search

One of the key challenges in computer networks is network security. For securing the network, various solutions have been proposed, including network security protocols and firewalls. In the case of so-called packet-filtering firewalls, policy rules are implemented to monitor changes to the network and preserve the required security level. Due to the dramatic increase of devices, however, and herewith the rapid increase of the size of the policy rules, firewall policy anomalies occur more frequently. This requires careful implementation of the policy rules to ensure cost-efficient solutions for anomaly detection to support network security. In this study, we present an anomaly detection framework for detecting intrafirewall policy anomaly rules. The framework supports the simulation of packets through the firewall ruleset for validating and enhancing the security level of the network. The framework is validated using four different types of firewall policy anomalies. Experimental results demonstrate that the framework is effective and efficient in detecting firewall policy anomalies. 1963-2012 IEEE. Scopus 2-s2.0-85112707923

Several formal systems, such as resolution and minimal model semantics, provide a framework for logic programming. In this paper, we will survey the use of structural proof theory as an alternative foundation. Researchers have been using this foundation for the past 35 years to elevate logic programming from its roots in first-order classical logic into higher-order versions of intuitionistic and linear logic. These more expressive logic programming languages allow for capturing stateful computations and rich forms of abstractions, including higher-order programming, modularity, and abstract data types. Term-level bindings are another kind of abstraction, and these are given an elegant and direct treatment within both proof theory and these extended logic programming languages. Logic programming has also inspired new results in proof theory, such as those involving polarity and focused proofs. These recent results provide a high-level means for presenting the differences between forward-chaining and backward-chaining style inferences. Anchoring logic programming in proof theory has also helped identify its connections and differences with functional programming, deductive databases, and model checking., To appear in Theory and Practice of Logic Programming (TPLP)

This paper discusses an implementation of a declarative style of programming for sensor-based applications, involving the acquisition and aggregation of context. We describe an implementation of LogicCAP integrating Prolog with the ContextToolkit, and its on-going extensions, considering applications in the mobile environment, distributed evaluation, and dynamic sensor binding issues. We also propose LogicCAP as a declarative language for context (and sensor) mashups with the situation as the aggregating abstraction.

We introduce Natlog, a lightweight Logic Programming language, sharing Prolog's unification-driven execution model, but with a simplified syntax and semantics. Our proof-of-concept Natlog implementation is tightly embedded in the Python-based deep-learning ecosystem with focus on content-driven indexing of ground term datasets. As an overriding of our symbolic indexing algorithm, the same function can be delegated to a neural network, serving ground facts to Natlog's resolution engine. Our open-source implementation is available as a Python package at https://pypi.org/project/natlog/ ., Comment: In Proceedings ICLP 2021, arXiv:2109.07914

In this paper, we present an informal introduction to Logical English (LE) and illustrate its use to standardise the legal wording of the Automatic Early Termination (AET) clauses of International Swaps and Derivatives Association (ISDA) Agreements. LE can be viewed both as an alternative to conventional legal English for expressing legal documents, and as an alternative to conventional computer languages for automating legal documents. LE is a controlled natural language (CNL), which is designed both to be computer-executable and to be readable by English speakers without special training. The basic form of LE is syntactic sugar for logic programs, in which all sentences have the same standard form, either as rules of the form conclusion if conditions or as unconditional sentences of the form conclusion. However, LE extends normal logic programming by introducing features that are present in other computer languages and other logics. These features include typed variables signalled by common nouns, and existentially quantified variables in the conclusions of sentences signalled by indefinite articles. Although LE translates naturally into a logic programming language such as Prolog or ASP, it can also serve as a neutral standard, which can be compiled into other lower-level computer languages.

Introduction. The organization of branches and repetitions in the context of logical programming is considered by an example of the Prolog language. The fundamental feature of the program in a logical programming language is the fact that a computer must solve a problem by reasoning like a human. Such a program contains a description of objects and relations between them in the language of mathematical logic. At the same time, the software implementation of branching and repetition remains a challenge in the absence of special operators for the indicated constructions in the logical language. The objectives of the study are to identify the most effective ways to solve problems using branching and repetition by means of the logic programming language Prolog, as well as to demonstrate the results obtained by examples of computational problems. Materials and Methods. An analysis of the literature on the subject of the study was carried out. Methods of generalization and systematization of knowledge, of the program testing, and analysis of the program execution were used. Results. Constructions of branching and repetition organization in a Prolog program are proposed. To organize repetitions, various options for completing a recursive cycle when solving problems are given. Discussion and Conclusions. The methods of organizing branches and repetitions in the logic programming language Prolog are considered. All these methods are illustrated by examples of solving computational problems. The results obtained can be used in the further development of the recursive predicates in logical programming languages, as well as in the educational process when studying logical programming in the Prolog language. The examples of programs given in the paper provide using them as a technological basis for programming branches and repetitions in the logic programming language Prolog.

The Regional Revenue Management Agency of Kebumen Regency is a government agency that manages regional revenue in Kebumen Regency. The design of automatic curtains is expected to make it easier for office employees to use the facilities. This automatic curtain uses a flow chart and programming logic in designing programs for the light intensity of the IR sensor and the LDR sensor as an automatic curtain indicator using a remote. The design of the automatic curtain consists of an IR sensor and an LDR sensor as input, Arduino UNO as a processor, Relay as a component that transmits commands from the Arduino UNO to the motor, and motor as the output of this project. Automatic curtains at BAPEDA Kebumen can make it easier for employees to use office facilities to make them more durable, more comfortable, and more effective during working hours or on holidays because of the automatic curtain system that has been made.

Unification is a central concept in logic systems based on the resolution principle. As well, in knowledge representation, proximity relations (i.e., reflexive, symmetric, fuzzy binary relations) are useful for introducing semantics into a syntactic level by modeling the semantic closeness of different syntactic objects and managing vague or imprecise information. Proximity relations, in combination with the unification algorithm, make possible expressing certain forms of approximate reasoning in a logic programming framework. In this article, we use proximity relations in the context of a (fuzzy) logic programming system, called Bousi $\sim$ Prolog , as a way of solving the limitations introduced by similarity relations (i.e., transitive proximity relations) to correctly represent fuzzy information. Recently, we introduced an accurate definition of proximity between expressions (terms or atomic formulas) and a new unification algorithm able to manage proximity relations properly. However, the so-called weak unification algorithm, which is an extension of Martelli and Montanari's unification algorithm supported by the new notion of proximity, does not have an efficient implementation. In this article, we present a method that facilitates such an efficient implementation, including an adaptation of the weak SLD resolution rule based on the new unification algorithm, and its integration and implementation into the fuzzy logic programming system Bousi $\sim$ Prolog . A performance analysis to show its efficiency is also presented.

Declarative process modelling languages focus on describing a process by restrictions over the behaviour, which must be satisfied throughout the whole process execution. Hence, they are well suited for modelling knowledge-intensive processes with many decision points. However, such models can be hard to read and understand, which affect the modelling and maintenance of the process models tremendously as well as their execution. When executing such declarative (multi-perspective) process models, it may happen that the execution of activities or the change of data values may result in the non-executability of crucial activities. Hence, it would be beneficial to know all consequences of decisions to give recommendations to the process participants. A look-ahead attempts to predict the effects of executing an activity towards possible consequences within an a priori defined time window. The prediction is based on the current state of the process execution, the intended next event and the underlying process model. While execution engines for single-perspective imperative process models already implement such functionality, execution approaches, for multi-perspective declarative process models that involve constraints on data and resources, are less mature. In this paper, we introduce a simulation-based look-ahead approach for multi-perspective declarative process models. This approach transforms the problem of a context-aware process simulation into a SAT problem, by translating a declarative multi-perspective process model and the current state of a process execution into a specification of the logic language Alloy. Via a SAT solver, process trajectories are generated that either satisfy or violate this specification. The simulated process trajectories are used to derive consequences and effects of certain decisions at any time of process execution. We evaluate our approach by means of three examples and give some advice for further optimizations.

The main goal of this work is to propose a tool-chain capable of analyzing a data collection of temporally qualified (genetic) mutation profiles, i.e., a collection of DNA-sequences (genes) that present variations with respect to their “healthy” versions. We implemented a system consisting of a front-end, a reasoning core, and a post-processor: the first transforms the input data retrieved from medical databases into a set of logical facts, while the last displays the computation results as graphs. Concerning the reasoning core, we employed the Answer Set Programming paradigm, which is capable of deducing complex information from data. However, since the system is modular, this component can be replaced by any logic programming tool for different kinds of data analysis. Indeed, we tested the use of a probabilistic inductive logic programming core.

State-of-the-art answer set programming (ASP) solvers rely on a program called a grounder to convert non-ground programs containing variables into variable-free, propositional programs. The size of this grounding depends heavily on the size of the non-ground rules, and thus, reducing the size of such rules is a promising approach to improve solving performance. To this end, in this paper we announce lpopt, a tool that decomposes large logic programming rules into smaller rules that are easier to handle for current solvers. The tool is specifically tailored to handle the standard syntax of the ASP language (ASP-Core) and makes it easier for users to write efficient and intuitive ASP programs, which would otherwise often require significant hand-tuning by expert ASP engineers. It is based on an idea proposed by Morak and Woltran (2012) that we extend significantly in order to handle the full ASP syntax, including complex constructs like aggregates, weak constraints, and arithmetic expressions. We present the algorithm, the theoretical foundations on how to treat these constructs, as well as an experimental evaluation showing the viability of our approach., Comment: Pre-proceedings paper presented at the 26th International Symposium on Logic-Based Program Synthesis and Transformation (LOPSTR 2016), Edinburgh, Scotland UK, 6-8 September 2016 (arXiv:1608.02534), 14 pages, LaTeX, 2 figures

Datalog is a declarative logic programming language that has been used in a variety of applications, including big-data analytics, language processing, networking and distributed systems, and program analysis. In this paper, we propose first-class Datalog constraints as a mechanism to construct, compose, and solve Datalog programs at run time. The benefits are twofold: We gain the full power of a functional programming language to operate on Datalog constraints-as-values, while simultaneously we can use Datalog where it really shines: to declaratively express and solve fixpoint problems. We present an extension of the lambda calculus with first-class Datalog constraints, including its semantics and a type system with row polymorphism based on Hindley-Milner. We prove soundness of the type system and implement it as an extension of the Flix programming language.

Satisfiability modulo theories (SMT) solving has become a critical part of many static analyses, including symbolic execution, refinement type checking, and model checking. We propose Formulog, a domain-specific language that makes it possible to write a range of SMT-based static analyses in a way that is both close to their formal specifications and amenable to high-level optimizations and efficient evaluation. Formulog extends the logic programming language Datalog with a first-order functional language and mechanisms for representing and reasoning about SMT formulas; a novel type system supports the construction of expressive formulas, while ensuring that neither normal evaluation nor SMT solving goes wrong. Our case studies demonstrate that a range of SMT-based analyses can naturally and concisely be encoded in Formulog, and that — thanks to this encoding — high-level Datalog-style optimizations can be automatically and advantageously applied to these analyses.

Static typing can guide programmers if feedback is immediate. Therefore, all major IDEs incrementalize type checking in some way. However, prior approaches to incremental type checking are often specialized and hard to transfer to new type systems. In this paper, we propose a systematic approach for deriving incremental type checkers from textbook-style type system specifications. Our approach is based on compiling inference rules to Datalog, a carefully limited logic programming language for which incremental solvers exist. The key contribution of this paper is to discover an encoding of the infinite typing relation as a finite Datalog relation in a way that yields efficient incremental updates. We implemented the compiler as part of a type system DSL and show that it supports simple types, some local type inference, operator overloading, universal types, and iso-recursive types.

The FASILL programming language (acronym of “Fuzzy Aggregators and Similarity Into a Logic Language”) combines a weak unification algorithm, based on similarity relations, along with a rich repertoire of fuzzy connectives and aggregators, whose truth functions can be defined on a complete lattice. In this work, we want to provide a unified view of the fundamental concepts and ideas that inspired its construction, jointly with the implementation techniques that made it possible. We detail the implementation of the operational semantics and we describe the overall structure of the FASILL system. The FASILL language is well-suited for a wide range of applications and, specifically, it can help the development of knowledge based systems where to deal with uncertainty is important. After ten years designing and implementing fuzzy logic systems, this work culminates and agglutinates the experience acquired in our research group on the development of this kind of modern programming languages.

Transparency is a key requirement for ethical machines. Verified ethical behavior is not enough to establish justified trust in autonomous intelligent agents: it needs to be supported by the ability to explain decisions. Logic Programming (LP) has a great potential for developing such perspective ethical systems, as in fact logic rules are easily comprehensible by humans. Furthermore, LP is able to model causality, which is crucial for ethical decision making., In Proceedings ICLP 2020, arXiv:2009.09158. Invited paper for the ICLP2020 Panel on "Machine Ethics". arXiv admin note: text overlap with arXiv:1909.08255

Extended multi-adjoint logic programming arises as an extension of multi-adjoint normal logic programming where constraints and a special type of aggregator operator have been included. The use of this general aggregator operator permits to consider, for example, different negation operators in the body of the rules of a logic program. We have introduced the syntax and the semantics of this new paradigm, as well as an interesting mechanism for obtaining a multi-adjoint normal logic program from an extended multi-adjoint logic program. This mechanism will allow us to establish technical properties relating the different stable models of both logic programming frameworks. Moreover, it makes possible that the already developed and future theory associated with stable models of multi-adjoint normal logic programs can be applied to extended multi-adjoint logic programs.

[EN] In this work, we say that a computation is reversible if one can find a procedure to undo the steps of a standard (or forward) computation in a deterministic way. While logic programs are often invertible (e.g., one can use the same predicate for adding and for subtracting natural numbers), computations are not reversible in the above sense. In this paper, we present a so-called Landauer embedding for SLD resolution, the operational principle of logic programs, so that it becomes reversible. A proof-of-concept implementation of a reversible debugger for Prolog that follows the ideas in this paper has been developed and is publicly available., This work is partially supported by the EU (FEDER) and the Spanish MCI/AEI under grants TIN2016-76843-C4-1-R/PID2019-104735RB-C41, by the Generalitat Valenciana under grant Prometeo/2019/098 (DeepTrust), and by the COST Action IC1405 on Reversible Computation - extending horizons of computing.

This article analyses the main legal requirements in the California Consumer Protection Act (CCPA), general data protection regulation (GDPR) and the intersections between privacy laws, genomic data and smart contracts (such as fungible and non-fungible tokens (NFTs). The CCPA and GDPR laws impose several restrictions on the storing, accessing, processing and transferring of personal data. This has generated some challenges for lawyers, data processors and business enterprises engaged in blockchain offerings, especially as they pertain to high-risk data sets such as genomic data. The technical features of NFT, distributed storage and wallets to trace and govern genomic (DNA) data sets will allow data donors to establish digital ownership and control in line with privacy laws using ‘programmable privacy smart contracts’. To be legally compliant, the design of blockchain value propositions should include privacy-by-design capabilities in the smart contract coding language itself. This article describes three domains (privacy laws, genomics and NFTs) and begins to explore how data engineers can address the challenges of coding privacy laws, the legal requirements into smart contracts. This current approach focuses on NFTs and genomic data requirements which include the selection of genetic metadata borrowing from developing ERC specifications and their programming logic. Programmable privacy is a unique way to write and design computer code, which can automatically check the legal compliance of the smart contract in a trust-less and decentralised way. We exemplify the approach by describing the conceptual value proposition of Genobank.io, a privacy-preserving genomic data platform.

Logic programming languages such as Datalog have become popular as Domain Specific Languages (DSLs) for solving large-scale, real-world problems, in particular, static program analysis and network analysis. The logic specifications that model analysis problems process millions of tuples of data and contain hundreds of highly recursive rules. As a result, they are notoriously difficult to debug. While the database community has proposed several data provenance techniques that address the Declarative Debugging Challenge for Databases, in the cases of analysis problems, these state-of-the-art techniques do not scale. In this article, we introduce a novel bottom-up Datalog evaluation strategy for debugging: Our provenance evaluation strategy relies on a new provenance lattice that includes proof annotations and a new fixed-point semantics for semi-naïve evaluation. A debugging query mechanism allows arbitrary provenance queries, constructing partial proof trees of tuples with minimal height. We integrate our technique into Soufflé, a Datalog engine that synthesizes C++ code, and achieve high performance by using specialized parallel data structures. Experiments are conducted with D OOP /DaCapo, producing proof annotations for tens of millions of output tuples. We show that our method has a runtime overhead of 1.31× on average while being more flexible than existing state-of-the-art techniques.

Description logic ontologies, such as ontologies written in OWL, and non-monotonic rules, as known in Logic Programming, are two major approaches in Knowledge Representation and Reasoning. Even though their integration is challenging due to their inherent differences, the need to combine their distinctive features stems from real world applications. In this paper, we give an overview of NoHR, a reasoner designed to answer queries over theories composed of an OWL ontology in a Description logic and a set of non-monotonic rules. NoHR has been developed as a plug-in for the widely used ontology editor Protege, building on a combination of reasoners dedicated to OWL and rules, but it is also available as a library, allowing for its integration within other environments and applications. It comes with support for all polynomial OWL profiles and the integration of their constructors as well as for standard built-in Prolog predicates, and allows the direct consultation of databases during query evaluation and the usage of sophisticated mechanisms, such as tabling already computed results, all of which enhances the applicability and the efficiency of query answering.

Logic Programming is a style of programming in which programs take the form of sets of sentences in the language of Symbolic Logic. Over the years, there has been growing interest in Logic Programming due to applications in deductive databases, automated worksheets, Enterprise Management (business rules), Computational Law, and General Game Playing. This book introduces Logic Programming theory, current technology, and popular applications. In this volume, we take an innovative, model-theoretic approach to logic programming. We begin with the fundamental notion of datasets, i.e., sets of ground atoms. Given this fundamental notion, we introduce views, i.e., virtual relations; and we define classical logic programs as sets of view definitions, written using traditional Prolog-like notation but with semantics given in terms of datasets rather than implementation. We then introduce actions, i.e., additions and deletions of ground atoms; and we define dynamic logic programs as sets of action definitions. In addition to the printed book, there is an online version of the text with an interpreter and a compiler for the language used in the text and an integrated development environment for use in developing and deploying practical logic programs. "This is a book for the 21st century: presenting an elegant and innovative perspective on logic programming. Unlike other texts, it takes datasets as a fundamental notion, thereby bridging the gap between programming languages and knowledge representation languages; and it treats updates on an equal footing with datasets, leading to a sound and practical treatment of action and change." – Bob Kowalski, Professor Emeritus, Imperial College London "In a world where Deep Learning and Python are the talk of the day, this book is a remarkable development. It introduces the reader to the fundamentals of traditional Logic Programming and makes clear the benefits of using the technology to create runnable specifications for complex systems." – Son Cao Tran, Professor in Computer Science, New Mexico State University "Excellent introduction to the fundamentals of Logic Programming. The book is well-written and well-structured. Concepts are explained clearly and the gradually increasing complexity of exercises makes it so that one can understand easy notions quickly before moving on to more difficult ideas." – George Younger, student, Stanford University

The connection between logic programming and formal argumentation has been studied starting from the landmark 1995 paper of Dung. Subsequent work has identified a standard translation from logic programs to (instantiated) argumentation frameworks, under which pairwise correspondences hold between various logic programming semantics and various formal argumentation semantics. This includes the correspondence between 3-valued stable and complete semantics, between well-founded and grounded semantics and between 2-valued stable (LP) and stable (argumentation) semantics. In the current paper, we show that the existing translation is able to yield the additional correspondence between ideal semantics for logic programming and ideal semantics for formal argumentation. We also show that correspondence does not hold between eager semantics for logic programming and eager semantics for formal argumentation, at least when translating from logic programming to formal argumentation. Overall, the current work should be seen as completing the analysis of correspondences between mainstream admissibility-based argumentation semantics and their logic programming counterparts.

Thom Fr\"uhwirth presented a short, elegant and efficient Prolog program for the n queens problem. However the program may be seen as rather tricky and one may not be convinced about its correctness. This paper explains the program in a declarative way, and provides proofs of its correctness and completeness. The specification and the proofs are declarative, i.e. they abstract from any operational semantics. The specification is approximate, it is unnecessary to describe the program's semantics exactly. Despite the program works on non-ground terms, this work employs the standard semantics, based on logical consequence and Herbrand interpretations. Another purpose of the paper is to present an example of precise declarative reasoning about the semantics of a logic program. Under consideration in Theory and Practice of Logic Programming (TPLP)., Comment: Under consideration in Theory and Practice of Logic Programming (TPLP). 13 pages, 1 figure. A re-worked version of arXiv:1909.07479

To date, logic-based technologies are either built on top or as extensions of the Prolog language, mostly working as monolithic solutions tailored upon specific inference procedures, unification mechanisms, or knowledge representation techniques. Instead, to maximise their impact, logic-based technologies should support and enable the general-purpose exploitation of all the manifold contributions from logic programming. Accordingly, we present 2 P-Kt , a reboot of the tu Prolog project offering a general, extensible, and interoperable ecosystem for logic programming and symbolic AI.

The declarative programming language Curry amalgamates demand-driven evaluation from functional programming with non-determinism from logic programming. In contrast to Prolog, the search strategy for non-deterministic computations is not fixed so that complete or parallel strategies are reasonable for Curry. In particular, a desirable option is a fair strategy which frees the programmer from considering the influence of the search strategy to the success of a computation. In this paper we describe an implementation with this property. Based on recent developments on operational models for functional logic programming, we present a new implementation which transforms Curry programs in several transformation steps into Go programs. By exploiting lightweight threads in the form of goroutines, we obtain a complete and fair implementation which automatically uses multi-processing to speed up non-deterministic computations. This has the effect that, in some cases, non-deterministic algorithms are more efficiently evaluated than deterministic ones.

The system titled Secure Coding Assistant was developed to automate early detection for a subset of the Java secure coding rules specified by the SEI CERT at the Carnegie Mellon University. This system can help Java programmers significantly reduce security vulnerabilities in their code caused by the violations of secure coding rules. Since other software defects can also lead to security vulnerabilities, efforts have been taken to extend Secure Coding Assistant aiming at empowering programmers to detect, locate and remove code errors during coding time. This paper presents an enhancement to Secure Coding Assistant by a combination of Design by Contract and Programming Logic. Java programmers using this system are advised to provide their design contracts, i.e., logic assertions, for program structures of methods, if-then-else statements and while-loop statements. The design contracts defined by programmers can be automatically checked at the time of their program execution. To further facilitate the process of detecting and locating of code errors, using the programmers-defined design contracts, sub-design contracts can be automatically generated by the system based on the inference rules for the if-then-else statement and the while-loop statement in programming logic. The sub-design contracts generated by the system can also be automatically checked at dynamic time. In addition, based on the assignment axiom and the inference rule for the sequence statement in programming logic, the weakest pre-conditions of certain assignment sequences can be automatically generated from the post-conditions of the sequences, enabling programmers to statically analyze the correctness of the corresponding design contracts they specify. With the enhancement presented, Secure Coding Assistant can assist programmers for the early detections of not only secure coding rule violations but also errors in code. These early detections are performed in unison with the coding process to pursue software security.

We introduce a novel logic-based system for reasoning over data streams, which relies on a framework enabling a tight, fine-tuned interaction between Apache Flink and the I^2-DLV system. The architecture allows to take advantage from both the powerful distributed stream processing capabilities of Flink and the incremental reasoning capabilities of I^2-DLV based on overgrounding techniques. Besides the system architecture, we illustrate the supported input language and its modeling capabilities, and discuss the results of an experimental activity aimed at assessing the viability of the approach. This paper is under consideration in Theory and Practice of Logic Programming (TPLP)., Paper presented at the 37th International Conference on Logic Programming (ICLP 2021), 16 pages

Smart environments enabled by the Internet of Things aim at improving our daily lives by automatically tuning ambient parameters and by achieving energy savings through self-managing cyber-physical systems. Commercial solutions, however, only permit setting simple target goals on those parameters and do not mediate between conflicting goals among different users and/or system administrators, nor across different IoT verticals. In this article, we propose a declarative approach (and its open-source Prolog prototype) to represent smart environments, user-set goals and customisable mediation policies to reconcile contrasting goals across multiple IoT systems.

This paper investigates the usage of logic and logic programming in the design of smart contracts. Our starting point is the logic-based programming language for smart contracts used in a recently proposed framework of quantum-secured blockchain, called Logicontract (LC). We then extend the logic used in LC by answer set programming (ASP), a modern approach to declarative logic programming. Using ASP enables us to write various interesting smart contracts, such as conditional payment, commitment, multi-party lottery and legal service. A striking feature of our ASP implementation proposal is that it involves post-quantum cryptographic primitives, such as the lattice-based public key encryption and signature. The adoption of the post-quantum cryptographic signature overcomes a specific limitation of LC in which the unconditionally secure signature, despite its strength, offers limited protection for users of the same node.

Syntactical rule based approaches for aspect extraction, which are free from expensive manual annotation, are promising in practice. These approaches extract aspects mainly through the dependency relations in the surface sentence structures. However, deep and rich semantic information hidden in sentences which can help improve aspect extraction, is difficult for them to capture. In order to address the problem, this paper first proposes to employ Logic Programming to explore the feasibility of deep semantic representation, then proposes Deep2S, a hybrid rule-based method to improve the performance of aspect extraction. Deep2S integrates deep semantic representation such as Abstract Meaning Representation (AMR) with syntactic structure. It can take advantage of the syntactical rules to obtain dependency relations in the surface structure as well as the semantic rules to capture deep semantic information. Our experiments are conducted on eight popular review datasets using two evaluation metrics. Experimental results demonstrate the usefulness of deep semantic representation and the ability of Deep2S to improve the performance of aspect extraction in opinion mining.

This article consists of a quantitative investigation that shows the results of the use of Edpuzzle as a learning tool in a face-to-face class of a programming course offered at the Technological University of Southern Sonora (UTS). The study consisted in the development of an interactive video on the Edpuzzle platform to deliver and evaluate a topic that students sometimes consider difficult to learn. The tool allowed the evaluation of the students who used the learning material developed for the topic. An analysis was made of the resulting information that showed a higher performance, with a difference of 17.14 percentage points, in the group that used the tool. Also, students participating in the experimental group expressed, through a non-formal interview, that the application seemed different to how the classes are conducted at the University, but they considered it very attractive, dynamic and interesting to use in future classes to support other topics.

This work refers to the creation of a didactic sequence composed of 4 classes to work moment arm in elementary education and introduction to programming logic. It can be applied to students in grades 5 through 9 of elementary school. The classes were instrumented by a robotic arm built in 3D printer and controlled by Arduino technology. There was also the study of programming logic, using the Scratch computer program installed in an electronic platform Raspberry Pi. The suggested mediation aims to promote five pedagogical relationships: student-teacher, studentstudent, student-environment, student-scientific knowledge and student-technology. With the application of the proposed didactic sequence, it can be noticed that the mentioned relations, besides motivating the students, allows a considerable influence on the conceptual reworking of the studied subjects and a better understanding of the programming logic., Este trabalho propõe uma sequência didática composta por 4 encontros para trabalhar o conteúdo ”momento de alavanca“ no ensino fundamental e introdução à lógica de programação. Pode ser aplicado a estudantes do 5o ao 9o ano do ensino fundamental. As aulas foram instrumentalizadas por um braço robótico construído em impressora 3D e controlado pela tecnologia Arduino. Também houve o estudo da lógica de programação, mediante o uso do programa computacional Scratch, instalado em uma plataforma eletrônica Raspberry Pi. A mediação sugerida visa promover cinco relações pedagógicas: aluno-professor, aluno-aluno, aluno-ambiente, aluno-saber científico e aluno-tecnologia. Com a aplicação da sequência didática proposta, pode-se perceber que as relações citadas, além de motivar os alunos, permitem uma considerável influência na reelaboração conceitual dos assuntos estudados e uma melhor compreensão da lógica de programação.

Autonomous intelligent agents are playing increasingly important roles in our lives. They contain information about us and start to perform tasks on our behalves. Chatbots are an example of such agents that need to engage in a complex conversations with humans. Thus, we need to ensure that they behave ethically. In this work we propose a hybrid logic-based approach for ethical chatbots., Comment: In Proceedings ICLP 2019, arXiv:1909.07646

Magic sets are a Datalog to Datalog rewriting technique to optimize query answering. The rewritten program focuses on a portion of the stable model(s) of the input program which is sufficient to answer the given query. However, the rewriting may introduce new recursive definitions, which can involve even negation and aggregations, and may slow down program evaluation. This paper enhances the magic set technique by preventing the creation of (new) recursive definitions in the rewritten program. It turns out that the new version of magic sets is closed for Datalog programs with stratified negation and aggregations, which is very convenient to obtain efficient computation of the stable model of the rewritten program. Moreover, the rewritten program is further optimized by the elimination of subsumed rules and by the efficient handling of the cases where binding propagation is lost. The research was stimulated by a challenge on the exploitation of Datalog/\textsc{dlv} for efficient reasoning on large ontologies. All proposed techniques have been hence implemented in the \textsc{dlv} system, and tested for ontological reasoning, confirming their effectiveness. Under consideration for publication in Theory and Practice of Logic Programming., Comment: Paper presented at the 35th International Conference on Logic Programming (ICLP 2019), Las Cruces, New Mexico, USA, 20-25 September 2019, 16 pages

Repeated executions of reasoning tasks for varying inputs are necessary in many applicative settings, such as stream reasoning. In this context, we propose an incremental grounding approach for the answer set semantics. We focus on the possibility of generating incrementally larger ground logic programs equivalent to a given non-ground one; so called overgrounded programs can be reused in combination with deliberately many different sets of inputs. Updating overgrounded programs requires a small effort, thus making the instantiation of logic programs considerably faster when grounding is repeated on a series of inputs similar to each other. Notably, the proposed approach works "under the hood", relieving designers of logic programs from controlling technical aspects of grounding engines and answer set systems. In this work we present the theoretical basis of the proposed incremental grounding technique, we illustrate the consequent repeated evaluation strategy and report about our experiments. This paper is under consideration in Theory and Practice of Logic Programming (TPLP)., Paper presented at the 35th International Conference on Logic Programming (ICLP 2019), Las Cruces, New Mexico, USA, 20-25 September 2019, 16 pages

The input language of the answer set solver clingo is based on the definition of a stable model proposed by Paolo Ferraris. The semantics of the ASP-Core language, developed by the ASP Standardization Working Group, uses the approach to stable models due to Wolfgang Faber, Nicola Leone, and Gerald Pfeifer. The two languages are based on different versions of the stable model semantics, and the ASP-Core document requires, "for the sake of an uncontroversial semantics," that programs avoid the use of recursion through aggregates. In this paper we prove that the absence of recursion through aggregates does indeed guarantee the equivalence between the two versions of the stable model semantics, and show how that requirement can be relaxed without violating the equivalence property. The paper is under consideration for publication in Theory and Practice of Logic Programming., Comment: Paper presented at the 35th International Conference on Logic Programming (ICLP 2019), Las Cruces, New Mexico, USA, 20-25 September 2019, 20 pages

Types in logic programming have focused on conservative approximations of program semantics by regular types, on one hand, and on type systems based on a prescriptive semantics defined for typed programs, on the other. In this paper, we define a new semantics for logic programming, where programs evaluate to true, false, and to a new semantic value called wrong, corresponding to a run-time type error. We then have a type language with a separated semantics of types. Finally, we define a type system for logic programming and prove that it is semantically sound with respect to a semantic relation between programs and types where, if a program has a type, then its semantics is not wrong. Our work follows Milner's approach for typed functional languages where the semantics of programs is independent from the semantic of types, and the type system is proved to be sound with respect to a relation between both semantics., Comment: In Proceedings ICLP 2019, arXiv:1909.07646

Delivering effective data analytics is of crucial importance to the interpretation of the multitude of biological datasets currently generated by an ever increasing number of high throughput techniques. Logic programming has much to offer in this area. Here, we detail advances that highlight two of the strengths of logical formalisms in developing data analytic solutions in biological settings: access to large relational databases and building analytical pipelines collecting graph information from multiple sources. We present significant advances on the bio_db package which serves biological databases as Prolog facts that can be served either by in-memory loading or via database backends. These advances include modularising the underlying architecture and the incorporation of datasets from a second organism (mouse). In addition, we introduce a number of data analytics tools that operate on these datasets and are bundled in the analysis package: bio_analytics. Emphasis in both packages is on ease of installation and use. We highlight the general architecture of our components based approach. An experimental graphical user interface via SWISH for local installation is also available. Finally, we advocate that biological data analytics is a fertile area which can drive further innovation in applied logic programming., In Proceedings ICLP 2019, arXiv:1909.07646

A generalized algorithm for the verification of functional models and the rules for the verification of diagrams related by levels of detail were developed in this paper. The algorithm is based on the analysis of a tree which describes the decompose relations in functional diagrams. At each step of the algorithm, a pair consisting of a parent diagram and a functional diagram is selected, and the correlation of the arrows and their roles is checked for both. The formalization of the verification rules was based on the set-theoretic representation of functional diagrams in the form of labeled oriented graphs. The rules make it possible to map the position and roles of the arrows associated with the detailed function block of the parent diagram to the arrows of the child diagram. The following rules for each of the possible arrow roles were established: “input”, “output”, “control”, “mechanism”. The use of the logic programming language PROLOG was proposed for the implementation of the algorithm. A knowledge base structure comprised of 3 interrelated predicates to describe the tree of diagrams, nodes and edges of the graphs was suggested. A query to check the verification rules was formed, and methods of binding variables and fixing roles were considered. The analysis and verification of a fragment of a functional model for the production of vinyl acetate from ethylene was conducted as an example. The functional diagrams for the processes “Condensate separation” and “Vinyl acetate isolation” connected by a decompose relation were developed, their set-theoretic models were constructed, and the use of rules for the verification of each type of arrow were considered.

MotivationA major challenge in molecular and cellular biology is to map out the regulatory networks of cells. As regulatory interactions can typically not be directly observed experimentally, various computational methods have been proposed to disentangling direct and indirect effects. Most of these rely on assumptions that are rarely met or cannot be adapted to a given context.ResultsWe present a network inference method that is based on a simple response logic with minimal presumptions. It requires that we can experimentally observe whether or not some of the system’s components respond to perturbations of some other components, and then identifies the directed networks that most accurately account for the observed propagation of the signal. To cope with the intractable number of possible networks, we developed a logic programming approach that can infer networks of hundreds of nodes, while being robust to noisy, heterogeneous or missing data. This allows to directly integrate prior network knowledge and additional constraints such as sparsity. We systematically benchmark our method on KEGG pathways, and show that it outperforms existing approaches in DREAM3 and DREAM4-challenges. Applied to a perturbation data set on PI3K and MAPK pathways in isogenic models of a colon cancer cell line, it generates plausible network hypotheses that explain distinct sensitivities towards EGFR inhibitors by different PI3K mutants.Availability and ImplementationA Python/Answer Set Programming implementation can be accessed at github.com/GrossTor/response-logic.Contactnils.bluethgen@charite.de