Prolog Implementation Research Articles

DNA logic programming: From concept to construction

AbstractDNA programming, which is based on the principle of base complementary pairing and Boolean operations, exhibits organizational structures and algorithms similar to those observed in machine language. Consequently, the practical implementation of DNA logic programming can be achieved through the utilization of programming techniques, enabling the discrimination and output generation. In recent years, DNA programming has witnessed a convergence with disciplines, such as life sciences, medicine, and other interdisciplinary areas, thereby giving rise to an advanced research system that yields valuable insights. This development has paved the way for multidisciplinary cutting‐edge research. Furthermore, the successful transition from conceptualization to the practical implementation of DNA programming has been accomplished. This review summarizes the recent advances in DNA logic programming within the biomedical fields, specifically emphasizing the conceptualization and execution of DNA logic programming constructs. The benefits and obstacles associated with the adoption of DNA programming in cutting‐edge research areas are also highlighted.

A formal, diagrammatic, and operational study of normative relations

Abstract In this work, we provide an extensive analysis of Hohfeld’s theory of normative relations, focusing in particular on diagrammatic structures. Our contribution is threefold. First, we specify an extensional formal language to represent the main notions in the two families of normative relations identified by Hohfeld (i.e. the deontic and the potestative family). Our primary focus is on the part of the theory concerning potestative relations. In this regard, we assign a key role to the concept of ability, which is treated as a primitive notion and used to formulate three fine-grained definitions of power (outcome-centered, change-centered and force-centered). Second, on the basis of these definitions we build Aristotelian diagrams of opposition for deontic and potestative relations, improving, extending and systematizing previous proposals formulated in the literature. Third, we present a model-theoretic interpretation and a logic programming (ASP) implementation of the proposed framework, elaborating on the procedural dimension of normative reasoning.

Quantitative extensions of reaction systems based on SOS semantics

Reaction systems (RSs) are a successful natural computing framework inspired by chemical reaction networks. A RS consists of a set of entities and a set of reactions. Entities can enable or inhibit each reaction and are produced by reactions or provided by the environment. In this paper, we define two quantitative variants of RSs: the first one is along the time dimension, to specify delays for making available reactions products and durations to protract their permanency, while the second deals with the possibility to specify different concentration levels of a substance in order to enable or inhibit a reaction. Technically, both extensions are obtained by modifying in a modular way the Structural Operational Semantics (SOS) for RSs that was already defined in the literature. Our approach maintains several advantages of the original semantics definition that were: (1) providing a formal specification of the RS dynamics that enables the reuse of many formal analysis techniques and favours the implementation of tools, and (2) making the RS framework extensible, by adding or changing some of the SOS rules in a compositional way. We provide a prototype logic programming implementation and apply our tool to three different case studies: the tumour growth, the Th cell differentiation in the immune system and neural communication.

Step: A Highly Expressive Text Generation Language

Games often generate text from human-authored templates and adapt that text to relevant context. Many systems have been developed to aid this process using tech-niques such as context-free grammars, randomization, logic programming, global state, and HTN planning. In this paper, I present Step, a novel programming language for text generation. So far as I can determine, previous techniques can all be implemented within Step using a few lines of code. This allows designers to mix-and-match features as needed, without having to write an interpreter for a new language. While extremely expressive as a programming language, Step is also intended to allow writers to add new text to an existing system with minimal markup and little knowledge of programming. In a head-to-head comparison, the Step implementation was more compact than, and used less markup than, a Prolog implementation of the same generator.

Making ProB Compatible with SWI-Prolog

AbstractEven though the core of the Prolog programming language has been standardized by ISO since 1995, it remains difficult to write complex Prolog programs that can run unmodified on multiple Prolog implementations. Indeed, implementations sometimes deviate from the ISO standard and the standard itself fails to cover many features that are essential in practice. Most Prolog applications thus have to rely on nonstandard features, often making them dependent on one particular Prolog implementation and incompatible with others. We examine one such Prolog application: ProB, which has been developed for over 20 years in SICStus Prolog. The article describes how we managed to refactor the codebase of ProB to also support SWI-Prolog, with the goal of verifying ProB’s results using two independent toolchains. This required a multitude of adjustments, ranging from extending the SICStus emulation in SWI-Prolog on to better modularizing the monolithic ProB codebase. We also describe notable compatibility issues and other differences that we encountered in the process, and how we were able to deal with them with few major code changes.

A Generalized Search Construct for Imperative Languages to Facilitate Declarative Programming

Search is one of the more common strategies used by problem-solving agents. For many hard problems, a backtracking search can be the most effective approach for finding a solution. Logic programming languages provide, as a core feature of the language, the mechanics for the search behind the scenes without requiring the user to specify the algorithm. However, this functionality has been generally left out of the core features of imperative programming languages. In this work, we propose integrating a search agent into an imperative programming language through a search construct in the syntax. By doing so, our intention is that the user may apply a declarative approach to problem solving. We extend the Go programming language with this search construct and develop an agent to perform the search. The algorithm behind the search is implicitly handled by the agent. We demonstrate the effectiveness of this search construct through solutions to an exhaustive search over a file-system, the NQueens problem, and the monkey and the bananas problem. To evaluate the performance of our agent, we compare its runtime performance against two of the common Prolog implementations, SWI-Prolog and GNU Prolog.

Fifty Years of Prolog and Beyond

AbstractBoth logic programming in general and Prolog in particular have a long and fascinating history, intermingled with that of many disciplines they inherited from or catalyzed. A large body of research has been gathered over the last 50 years, supported by many Prolog implementations. Many implementations are still actively developed, while new ones keep appearing. Often, the features added by different systems were motivated by the interdisciplinary needs of programmers and implementors, yielding systems that, while sharing the “classic” core language, in particular, the main aspects of the ISO-Prolog standard, also depart from each other in other aspects. This obviously poses challenges for code portability. The field has also inspired many related, but quite different languages that have created their own communities. This article aims at integrating and applying the main lessons learned in the process of evolution of Prolog. It is structured into three major parts. First, we overview the evolution of Prolog systems and the community approximately up to the ISO standard, considering both the main historic developments and the motivations behind several Prolog implementations, as well as other logic programming languages influenced by Prolog. Then, we discuss the Prolog implementations that are most active after the appearance of the standard: their visions, goals, commonalities, and incompatibilities. Finally, we perform a SWOT analysis in order to better identify the potential of Prolog and propose future directions along with which Prolog might continue to add useful features, interfaces, libraries, and tools, while at the same time improving compatibility between implementations.

Optimizing a tableau reasoner and its implementation in Prolog

One of the foremost reasoning services for knowledge bases is finding all the justifications for a query. This is useful for debugging purpose and for coping with uncertainty. Among Description Logics (DLs) reasoners, the tableau algorithm is one of the most used. However, in order to collect the justifications, the reasoners must manage the non-determinism of the tableau method. For these reasons, a Prolog implementation can facilitate the management of such non-determinism.The TRILL framework contains three probabilistic reasoners written in Prolog: TRILL, TRILLP and TORNADO. Since they are all part of the same framework, the choice about which to use can be done easily via the framework settings. Each one of them uses different approaches for probabilistic inference and handles different DLs flavors. Our previous work showed that they can sometimes achieve better results than state-of-the-art (non-)probabilistic reasoners.In this paper we present two optimizations that improve the performances of the TRILL reasoners. The first one consists into identifying the fragment of the KB that allows to perform inference without losing the completeness. The second one modifies which tableau rule to apply and their order of application, in order to reduce the number of operations. Experimental results show the effectiveness of the introduced optimizations.

Social Modeling via Logic Programming in City of Gangsters

City of Gangsters is a commercial strategy game with significant social modeling mechanics: it is a tycoon management game, where the player needs to work their social connections with a network of roughly 1200 NPCs to get things done, and NPC opinions about the player modulate the player's ability to succeed. We found logic programming to be well suited to our knowledge representation problem, including the need to perform inferences over a relationship network with more than a thousand active characters, and to provide the player with meaningful feedback about the consequences of their actions in the social space. In this paper we present the technical details of this social modeling problem, the details of our logic programming implementation, and how this interacts with the game's design and its social and material economies.

Optimizing a Tableau Reasoner and Its Implementation in Prolog

One of the foremost reasoning services for knowledge bases is finding all the justifications for a query. This is useful for debugging purpose and for coping with uncertainty. Among Description Logics (DLs) reasoners, the tableau algorithm is one of the most used. However, in order to collect the justifications, the reasoners must manage the non-determinism of the tableau method. For these reasons, a Prolog implementation can facilitate the management of such non-determinism. The TRILL framework contains three probabilistic reasoners written in Prolog: TRILL, TRILL and TORNADO. Since they are all part of the same framework, the choice about which to use can be done easily via the framework settings. Each one of them uses different approaches for probabilistic inference and handles different DLs flavours. Our previous work showed that they can sometimes achieve better results than state-of-the-art (non-)probabilistic reasoners. In this paper we present two optimizations that improve the performances of the TRILL reasoners. The first one consists into identifying the fragment of the KB that allows to perform inference without losing the completeness. The second one modifies which tableau rule to apply and their order of application, in order to reduce the number of operations. Experimental results show the effectiveness of the introduced optimizations.

Online Event Recognition from Moving Vehicles: Application Paper

AbstractWe present a system for online composite event recognition over streaming positions of commercial vehicles. Our system employs a data enrichment module, augmenting the mobility data with external information, such as weather data and proximity to points of interest. In addition, the composite event recognition module, based on a highly optimised logic programming implementation of the Event Calculus, consumes the enriched data and identifies activities that are beneficial in fleet management applications. We evaluate our system on large, real-world data from commercial vehicles, and illustrate its efficiency.

Solving Quantifier-Free First-Order Constraints Over Finite Sets and Binary Relations

In this paper we present a solver for a first-order logic language where sets and binary relations can be freely and naturally combined. The language can express, at least, any full set relation algebra on finite sets. It provides untyped, hereditarily finite sets, whose elements can be variables, and basically all the classic set and relational operators used in formal languages such as B and Z. Sets are first-class entities in the language, thus they are not encoded in lower level theories. Relations are just sets of ordered pairs. The solver exploits set unification and set constraint solving as primitive features. The solver is proved to be a sound semi-decision procedure for the accepted language. A Prolog implementation is presented and an extensive empirical evaluation provides evidence of its usefulness.

Probabilistic DL Reasoning with Pinpointing Formulas: A Prolog-based Approach

AbstractWhen modeling real-world domains, we have to deal with information that is incomplete or that comes from sources with different trust levels. This motivates the need for managing uncertainty in the Semantic Web. To this purpose, we introduced a probabilistic semantics, named DISPONTE, in order to combine description logics (DLs) with probability theory. The probability of a query can be then computed from the set of its explanations by building a Binary Decision Diagram (BDD). The set of explanations can be found using thetableau algorithm, which has to handle non-determinism. Prolog, with its efficient handling of non-determinism, is suitable for implementing the tableau algorithm. TRILL and TRILLPare systems offering a Prolog implementation of the tableau algorithm. TRILLPbuilds apinpointing formulathat compactly represents the set of explanations and can be directly translated into a BDD. Both reasoners were shown to outperform state-of-the-art DL reasoners. In this paper, we present an improvement of TRILLP, named TORNADO, in which the BDD is directly built during the construction of the tableau, further speeding up the overall inference process. An experimental comparison shows the effectiveness of TORNADO. All systems can be tried online in the TRILL on SWISH web application athttp://trill.ml.unife.it/.

A Fuzzy Datalog Deductive Database System

This paper describes a proposal for a deductive database system with fuzzy Datalog as its query language. Concepts supporting the fuzzy logic programming system Bousi~Prolog are tailored to the needs of the deductive database system DES. We develop a version of fuzzy Datalog where programs and queries are compiled to the DES core Datalog language. Weak unification and weak SLD resolution are adapted for this setting, and extended to allow rules with truth degree annotations. We provide a public implementation in Prolog, which is open source, multiplatform, portable, and in-memory, featuring a graphical user interface. A distinctive feature of this system is that, unlike others, we have formally demonstrated that our implementation techniques fit the proposed operational semantics. We also study the efficiency of these implementation techniques through a series of detailed experiments. Moreover, a database example for a recommender system is used to illustrate some of the features of the system and its usefulness.

Implementation of 3-Valued Paraconsistent Logic Programming Towards Decision Making System of Agents

Due to the rapid development of applications of artificial intelligence and robotics in recent years, the necessity of reasoning and decision making with uncertain and inaccurate information is increasing. Since robots in the real world are always exposed to behavioral inaccuracies and uncertainty arising from recognition methods, they may occasionally encounter contradictory facts during reasoning on action decision. Paraconsistent logic programming is promising to make appropriate action decisions even when an agent is exposed to such uncertain information or contradictory facts, but there has been no implementation of this programming to the best of our knowledge. We propose a resolution algorithm for the 3-valued paraconsistent logic programming system QMPT0 and its implementation on SWI-Prolog. We also describe an application of the 3-valued paraconsistent logic programming regarding agent decision making.

Detection of app collusion potential using logic programming

Mobile devices pose a particular security risk because they hold personal details (accounts, locations, contacts, photos) and have capabilities potentially exploitable for eavesdropping (cameras/microphone, wireless connections). The Android operating system is designed with a number of built-in security features such as application sandboxing and permission-based access control. Unfortunately, these restrictions can be bypassed, without the user noticing, by colluding apps whose combined permissions allow them to carry out attacks that neither app is able to execute by itself.While the possibility of app collusion was first warned in 2011, it has been unclear if collusion is used by malware in the wild due to a lack of suitable detection methods and tools. This paper describes how we found the first collusion in the wild. We also present a strategy for detecting collusions and its implementation in Prolog that allowed us to make this discovery.Our detection strategy is grounded in concise definitions of collusion and the concept of ASR (Access-Send-Receive) signatures. The methodology is supported by statistical evidence. Our approach scales and is applicable to inclusion into professional malware detection systems: we applied it to a set of more than 50,000 apps collected in the wild. Code samples of our tool as well as of the detected malware are available.

Application of natural language processing methods to extract coded data from administrative data held in the Scottish Prescribing Information System

ABSTRACT
 ObjectivesThe Prescribing Information System (PIS) datamart, hosted by NHS National Services Scotland receives around 90 million electronic prescription messages per year from GP practices across Scotland. Prescription messages contain information including drug name, quantity and strength stored as coded, machine readable, data while prescription dose instructions are unstructured free text and difficult to interpret and analyse in volume.
 The aim, using Natural Language Processing (NLP), was to extract drug dose amount, unit and frequency metadata from freely typed text in dose instructions to support calculating the intended number of days’ treatment. This then allows comparison with actual prescription frequency, treatment adherence and the impact upon prescribing safety and effectiveness.
 ApproachAn NLP algorithm was developed using the Ciao implementation of Prolog to extract dose amount, unit and frequency metadata from dose instructions held in the PIS datamart for drugs used in the treatment of gastrointestinal, cardiovascular and respiratory disease. Accuracy estimates were obtained by randomly sampling 0.1% of the distinct dose instructions from source records, comparing these with metadata extracted by the algorithm and an iterative approach was used to modify the algorithm to increase accuracy and coverage.
 ResultsThe NLP algorithm was applied to 39,943,465 prescription instructions issued in 2014, consisting of 575,340 distinct dose instructions. For drugs used in the gastrointestinal, cardiovascular and respiratory systems (i.e. chapters 1, 2 and 3 of the British National Formulary (BNF)) the NLP algorithm successfully extracted drug dose amount, unit and frequency metadata from 95.1%, 98.5% and 97.4% of prescriptions respectively. However, instructions containing terms such as ‘as directed’ or ‘as required’ reduce the usability of the metadata by making it difficult to calculate the total dose intended for a specific time period as 7.9%, 0.9% and 27.9% of dose instructions contained terms meaning ‘as required’ while 3.2%, 3.7% and 4.0% contained terms meaning ‘as directed’, for drugs used in BNF chapters 1, 2 and 3 respectively.
 ConclusionThe NLP algorithm developed can extract dose, unit and frequency metadata from text found in prescriptions issued to treat a wide range of conditions and this information may be used to support calculating treatment durations, medicines adherence and cumulative drug exposure. The presence of terms such as ‘as required’ and ‘as directed’ has a negative impact on the usability of the metadata and further work is required to determine the level of impact this has on calculating treatment durations and cumulative drug exposure.

Nested sequent calculi and theorem proving for normal conditional logics: The theorem prover NESCOND

In this paper we focus on proof methods and theorem proving for normal conditional logics, by describing nested sequent calculi as well as a theorem prover for them. We first present some nested sequent calculi, recently introduced, for the basic conditional logic CK and some of its significant extensions with axioms ID, MP and CEM. We also describe a calculus for the flat fragment of the conditional logic CK+CSO+ID, which corresponds to Kraus, Lehmann and Magidor’s cumulative logic C. The calculi are internal, cut-free and analytic. Next, we describe NESCOND, a Prolog implementation of these calculi in the style of leanTAP. We finally present an experimental comparison between our theorem prover NESCOND and other known theorem provers for conditional logics. Our tests show that the performances of NESCOND are promising and in all cases better, with the only exception of systems including CEM, than those ones of the other provers. The program NESCOND, as well as all the Prolog source files, are available at http://www.di.unito.it/∼pozzato/nescond/.

FLAME: a formal framework for the automated analysis of software product lines validated by automated specification testing

In a literature review on the last 20 years of automated analysis of feature models, the formalization of analysis operations was identified as the most relevant challenge in the field. This formalization could provide very valuable assets for tool developers such as a precise definition of the analysis operations and, what is more, a reference implementation, i.e., a trustworthy, not necessarily efficient implementation to compare different tools outputs. In this article, we present the FLAME framework as the result of facing this challenge. FLAME is a formal framework that can be used to formally specify not only feature models, but other variability modeling languages (VML s) as well. This reusability is achieved by its two-layered architecture. The abstract foundation layer is the bottom layer in which all VML-independent analysis operations and concepts are specified. On top of the foundation layer, a family of characteristic model layers—one for each VML to be formally specified—can be developed by redefining some abstract types and relations. The verification and validation of FLAME has followed a process in which formal verification has been performed traditionally by manual theorem proving, but validation has been performed by integrating our experience on metamorphic testing of variability analysis tools, something that has shown to be much more effective than manually designed test cases. To follow this automated, test-based validation approach, the specification of FLAME, written in Z, was translated into Prolog and 20,000 random tests were automatically generated and executed. Tests results helped to discover some inconsistencies not only in the formal specification, but also in the previous informal definitions of the analysis operations and in current analysis tools. After this process, the Prolog implementation of FLAME is being used as a reference implementation for some tool developers, some analysis operations have been formally specified for the first time with more generic semantics, and more VML s are being formally specified using FLAME.

Proof Outlines as Proof Certificates: A System Description

We apply the foundational proof certificate (FPC) framework to the problem of designing high-level outlines of proofs. The FPC framework provides a means to formally define and check a wide range of proof evidence. A focused proof system is central to this framework and such a proof system provides an interesting approach to proof reconstruction during the process of proof checking (relying on an underlying logic programming implementation). Here, we illustrate how the FPC framework can be used to design proof outlines and then to exploit proof checkers as a means for expanding outlines into fully detailed proofs. In order to validate this approach to proof outlines, we have built the ACheck system that allows us to take a sequence of theorems and apply the proof outline "do the obvious induction and close the proof using previously proved lemmas".