Prolog Programs Research Articles

An efficient propositional system for Abductive Logic Programming

Abductive logic programming (ALP) extends logic programming with hypothetical reasoning by means of abducibles, an extension able to handle interesting problems, such as diagnosis, planning, and verification with formal methods. Implementations of this extension have been using Prolog meta-interpreters and Prolog programs with Constraint Handling Rules (CHR). While the latter adds a clean and efficient interface to the host system, it still suffers in performance for large programs. Here, the concern is to obtain a more performant implementation of the SCIFF system following a compiled approach. This paper, as a first step in this long term goal, sets out a propositional ALP system following SCIFF, eliminating the need for CHR and achieving better performance.

Logic + probabilistic programming + causal laws.

Probabilistic planning attempts to incorporate stochastic models directly into the planning process, which is the problem of synthesizing a sequence of actions that achieves some objective for a putative agent. Probabilistic programming has rapidly emerged as a key paradigm to integrate probabilistic concepts with programming languages, which allows one to specify complex probabilistic models using programming primitives like recursion and loops. Probabilistic logic programming aims to further ease the specification of structured probability distributions using first-order logical artefacts. In this article, we briefly discuss the modelling of probabilistic planning through the lens of probabilistic (logic) programming. Although many flavours for such an integration are possible, we focus on two representative examples. The first is an extension to the popular probabilistic logic programming language PROBLOG, which permits the decoration of probabilities on Horn clauses-that is, prolog programs. The second is an extension to the popular agent programming language GOLOG, which permits the logical specification of dynamical systems via actions, effects and observations. The probabilistic extensions thereof emphasize different strengths of probabilistic programming that are particularly useful for non-trivial modelling issues raised in probabilistic planning. Among other things, one can instantiate planning problems with growing and shrinking state spaces, discrete and continuous probability distributions, and non-unique prior distributions in a first-order setting.

Space Syntax with Logic Programming: An Application to a Modern Estate

Space syntax is a set of theories and techniques for analysing urban settlements and buildings. Here, we propose a new approach to perform syntactic analyses that requires only the declaration in a computer program of the connections between axial lines or convex spaces using Prolog, a logic programming language concerned with artificial intelligence. With this new tool, we found that the deep tree nature of modern estates can be mitigated with a concentric structure similar to the famous Bororo village. In fact, Portela, a high-rise settlement near Lisbon (Portugal), is structured around a central open space (green park) equipped with noninterchangeable facilities (mall, sports centre and church), which are highly synchronised with the surrounding buildings (towers and blocks). The transpatial relations between housing estates and the central zone are maximised either by a distributive ringy network or by a smart grid of pedestrian paths. The result is a compact and integrated settlement with a strong identity and sense of belonging. Nevertheless, this kind of concentric dual system is potentially unstable, a problem that was minimised by forcing a clear opposition with a popular neighbourhood at Portela’s vicinity. With this case study, we show how logic programming is a useful tool to describe the patterns of discrete systems as social knowables due to its declarative nature. In fact, a Prolog program represents a certain amount of knowledge, namely, concerned with the structure of an urban settlement (or building), which could be used to answer queries about the social and economic consequences of certain spatial designs.

A Prolog assisted search for new simple Lie algebras

We describe some recent computer investigations with the ‘Constraint Logic Programming over Finite Domains’ library in the Prolog programming environment to search for new simple Lie algebras over the field GF ⁡ ( 2 ) \operatorname {GF}(2) of 2 2 elements. Motivated by a paper of Grishkov et al., we specifically look for those with a thin decomposition, and we settle one of their conjectures. We extrapolate from our results the existence of two new infinite families of simple Lie algebras, in addition to finding seven new sporadic examples in dimension 31 31 . We also better contextualise some previously discovered simple algebras, putting them into families which do not seem to have ever appeared in the literature, and give an updated table of those currently known.

Extension of constraint-procedural logic-generated environments for deep Q-learning agent training and benchmarking

Abstract Autonomous robots can be employed in exploring unknown environments and performing many tasks, such as, e.g. detecting areas of interest, collecting target objects, etc. Deep reinforcement learning (RL) is often used to train this kind of robot. However, concerning the artificial environments aimed at testing the robot, there is a lack of available data sets and a long time is needed to create them from scratch. A good data set is in fact usually produced with high effort in terms of cost and human work to satisfy the constraints imposed by the expected results. In the first part of this paper, we focus on the specification of the properties of the solutions needed to build a data set, making the case of environment exploration. In the proposed approach, rather than using imperative programming, we explore the possibility of generating data sets using constraint programming in Prolog. In this phase, geometric predicates describe a virtual environment according to inter-space requirements. The second part of the paper is focused on testing the generated data set in an AI gym via space search techniques. We developed a Neuro-Symbolic agent built from the following: (i) A deep Q-learning component implemented in Python, able to address via RL a search problem in the virtual space; the agent has the goal to explore a generated virtual environment to seek for a target, improving its performance through a RL process. (ii) A symbolic component able to re-address the search when the Q-learning component gets stuck in a part of the virtual environment; these components stimulate the agent to move to and explore other parts of the environment. Wide experimentation has been performed, with promising results, and is reported, to demonstrate the effectiveness of the approach.

Construction of womenswear matching expert system based on domain knowledge

Clothing matching refers to the coordination of style, color, etc. to achieve a decent and generous effect. With the development of artificial intelligence, increasing research efforts have been dedicated to complementary garment collocation as matching clothes to make a suitable outfit has become a daily headache for many people. However, existing studies neglect rules regarding clothing matching, which are based on the knowledge accumulated in the fashion domain and are implicitly transmitted and ambiguous. Towards this end, this article proposes an expert system based on domain knowledge implemented using the Prolog program to realize rule-guided clothing collocation. The article constructs clothing matching rules from four essential clothing attributes: season, type, style, and color, and uses Prolog syntax for knowledge representation. For the formulated facts and rules, the reasoning machine iteratively matches the user's instructions with the system knowledge to reason out suitable matching suggestions. In this study we built a website as a man-machine interface to facilitate friendly interaction and set season, type, style, and color sub-options to match clothing and satisfy user preferences. The system validation based on standard metrics (precision, recall, F1-measure) achieves results above 81%. The main contribution is that the system could match clothes more accurately according to the likes and requirements of users. After comparing with other research, the system is expected to provide suggestions or references for people to choose style and dressing.

A Gaze into the Internal Logic of Graph Neural Networks, with Logic

Graph Neural Networks share with Logic Programming several key relational inference mechanisms. The datasets on which they are trained and evaluated can be seen as database facts containing ground terms. This makes possible modeling their inference mechanisms with equivalent logic programs, to better understand not just how they propagate information between the entities involved in the machine learning process but also to infer limits on what can be learned from a given dataset and how well that might generalize to unseen test data. This leads us to the key idea of this paper: modeling with the help of a logic program the information flows involved in learning to infer from the link structure of a graph and the information content of its nodes properties of new nodes, given their known connections to nodes with possibly similar properties. The problem is known as graph node property prediction and our approach will consist in emulating with help of a Prolog program the key information propagation steps of a Graph Neural Network's training and inference stages. We test our a approach on the ogbn-arxiv node property inference benchmark. To infer class labels for nodes representing papers in a citation network, we distill the dependency trees of the text associated to each node into directed acyclic graphs that we encode as ground Prolog terms. Together with the set of their references to other papers, they become facts in a database on which we reason with help of a Prolog program that mimics the information propagation in graph neural networks predicting node properties. In the process, we invent ground term similarity relations that help infer labels in the test set by propagating node properties from similar nodes in the training set and we evaluate their effectiveness in comparison with that of the graph's link structure. Finally, we implement explanation generators that unveil performance upper bounds inherent to the dataset. As a practical outcome, we obtain a logic program, that, when seen as machine learning algorithm, performs close to the state of the art on the node property prediction benchmark.

Abductive Reasoning in Intuitionistic Propositional Logic via Theorem Synthesis

AbstractWith help of a compact Prolog-based theorem prover for Intuitionistic Propositional Logic, we synthesize minimal assumptions under which a given formula formula becomes a theorem. After applying our synthesis algorithm to cover basic abductive reasoning mechanisms, we synthesize conjunctions of literals that mimic rows of truth tables in classical or intermediate logics and we abduce conditional hypotheses that turn the theorems of classical or intermediate logics into theorems in intuitionistic logic. One step further, we generalize our abductive reasoning mechanism to synthesize more expressive sequent premises using a minimal set of canonical formulas, to which arbitrary formulas in the calculus can be reduced while preserving their provability. Organized as a self-contained literate Prolog program, the paper supports interactive exploration of its content and ensures full replicability of our results.

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.

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.

Conflict-Driven Inductive Logic Programming

AbstractThe goal of inductive logic programming (ILP) is to learn a program that explains a set of examples. Until recently, most research on ILP targeted learning Prolog programs. The ILASP system instead learns answer set programs (ASP). Learning such expressive programs widens the applicability of ILP considerably; for example, enabling preference learning, learning common-sense knowledge, including defaults and exceptions, and learning non-deterministic theories. Early versions of ILASP can be considered meta-level ILP approaches, which encode a learning task as a logic program and delegate the search to an ASP solver. More recently, ILASP has shifted towards a new method, inspired by conflict-driven SAT and ASP solvers. The fundamental idea of the approach, called Conflict-driven ILP (CDILP), is to iteratively interleave the search for a hypothesis with the generation of constraints which explain why the current hypothesis does not cover a particular example. These coverage constraints allow ILASP to rule out not just the current hypothesis, but an entire class of hypotheses that do not satisfy the coverage constraint. This article formalises the CDILP approach and presents the ILASP3 and ILASP4 systems for CDILP, which are demonstrated to be more scalable than previous ILASP systems, particularly in the presence of noise.

VeriFly: On-the-fly Assertion Checking via Incrementality

AbstractAssertion checking is an invaluable programmer’s tool for finding many classes of errors or verifying their absence in dynamic languages such as Prolog. For Prolog programmers, this means being able to have relevant properties, such as modes, types, determinacy, nonfailure, sharing, constraints, and cost, checked and errors flagged without having to actually run the program. Such global static analysis tools are arguably most useful the earlier they are used in the software development cycle, and fast response times are essential for interactive use. Triggering a full and precise semantic analysis of a software project every time a change is made can be prohibitively expensive. This is specially the case when complex properties need to be inferred for large, realistic code bases. In our static analysis and verification framework, this challenge is addressed through a combination of modular and incremental (context- and path-sensitive) analysis that is responsive to program edits, at different levels of granularity. In this tool paper, we present how the combination of this framework within an integrated development environment (IDE) takes advantage of such incrementality to achieve a high level of reactivity when reflecting analysis and verification results back as colorings and tooltips directly on the program text – the tool’s VeriFly mode. The concrete implementation that we describe is Emacs-based and reuses in part off-the-shelf “on-the-fly” syntax checking facilities (flycheck). We believe that similar extensions are also reproducible with low effort in other mature development environments. Our initial experience with the tool shows quite promising results, with low latency times that provide early, continuous, and precise assertion checking and other semantic feedback to programmers during the development process. The tool supports Prolog natively, as well as other languages by semantic transformation into Horn clauses.

Evolution of Artificial Intelligence Programming Languages - a Systematic Literature Review

Artificial Intelligence (AI) has received significant attention in recent years. It is being adopted to provide solutions to medicine, engineering, education, government and several other domains. To analyze the state-of-the-art of research in AI, we present a systematic literature review focusing on the Evolution of AI programming languages. Our search returned 7,604 documents; after reviewing these documents, 78 which were relevant for this study were retained. Our research revealed that the prevalence of AI programming language by volume of publications had experienced peaks and valleys between 1963 and 2018; however, between 2015 to 2020, related publications have been experiencing peaks. During the review period, the PROLOG programming language received the most attention in about 49% of publications; this was followed by LISP, which received almost 22%. The remaining attention was shared between Logic and Object-Oriented Programming (LOOP), ARCHLOG, Epistemic Ontology Language with Constraints (EOLC), Python, C++, ADA and JAVA. However, the predominant AI programming language in recent AI software is C/C++, which takes 70% of the modern AI libraries analyzed in this study. Python is used in 60% of the modern AI libraries analyzed. Their prevalence is as a result of their speed, portability and ease of coding, making them effective in developing trending AI libraries such as TensorFlow and Keras.

On Correctness and Completeness of annQueens Program

AbstractThom Frühwirth presented a short, elegant, and efficient Prolog program for thenqueens 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, that is 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.

Theoretical foundations of the organization of branches and repetitions in programs in the logic programming language Prolog

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.

Theoretical Foundations of the Organization of Banches and Repetitions in Programs in the Logical Programming Language Prolog

Theoretical Foundations of the Organization of Banches and Repetitions in Programs in the Logical Programming Language Prolog

Analysis of the methods for competing recursion in recursive riles in the logic programming language Prolog

One of the developing trends in programming is the logic programming associated with the implementation of tools for creating artificial intelligence. One of such programming languages is the nonprocedural declarative logic programming language Prolog. This article is dedicated to the use of recursive rules in Prolog software. The goal of this work lies in analysis of the methods for completing recursive calls in recursive rules, as well as in explication of the use of such methods on the examples of programs with recursion. The author explores the specialized literature on the topic, generalized and systematizes the data, as well as tested the programs and the progress of their implementation. Recursive rule in the Prolog software sets an infinite cycle of repetition of predicates. For completing the recursive cycle, it is necessary to set a condition within the program that would end the cycle. The article examines the variants of organizing recursions with the completion of infinite cycle. The examples used in the article allows using them as the basis for programming in language Prolog for solving similar tasks. The acquired results are valuable for further development of the use of recursive predicates in logic programming languages.

Deriving Efficient Sequential and Parallel Generators for Closed Simply-Typed Lambda Terms and Normal Forms

Contrary to several other families of lambda terms, no closed formula or generating function is known and none of the sophisticated techniques devised in analytic combinatorics can currently help with counting or generating the set of simply-typed closed lambda terms of a given size. Moreover, their asymptotic scarcity among the set of closed lambda terms makes counting them via brute force generation and type inference quickly intractable, with previous published work showing counts for them only up to size 10. By taking advantage of the synergy between logic variables, unification with occurs check and efficient backtracking in today’s Prolog systems, we climb 4 orders of magnitude above previously known counts by deriving progressively faster sequential Prolog programs that generate and/or count the set of closed simply-typed lambda terms of sizes up to 14. Similar counts for closed simply-typed normal forms are also derived up to size 14. Finally, we devise several parallel execution algorithms, based on generating code to be uniformly distributed among the available cores, that push the counts for simply typed terms up to size 15 and simply typed normal forms up to size 16. As a remarkable feature, our parallel algorithms are linearly scalable with the number of available cores.

Верификация знаний, полученных при изучении моделей бизнес-процессов

The paper focuses on the method of formal verification of knowledge obtained in the study of business process models. As a formal language for the presentation and verification of business processes, a certain version of π-calculus was chosen, and linear temporal modal logic was chosen as a language for formulating test assignments, i.e., questions, to be checked. The paper gives the rationale for such choice, and considers the principles of developing the test assignments in the language of modal logic and their usage for knowledge verification. The study proposes to automate knowledge testing with logic programs obtained as a result of the transition from a description of business processes to a verification program in the logical programming language Visual Prolog. The formal knowledge verification technique is illustrated by examples of knowledge verification. Findings of research show how the transition from the description of business processes to the procedures of formal verification of knowledge is carried out. The prospects for the development of the proposed method are discussed

Deriving Theorems in Implicational Linear Logic, Declaratively

The problem we want to solve is how to generate all theorems of a given size in the implicational fragment of propositional intuitionistic linear logic. We start by filtering for linearity the proof terms associated by our Prolog-based theorem prover for Implicational Intuitionistic Logic. This works, but using for each formula a PSPACE-complete algorithm limits it to very small formulas. We take a few walks back and forth over the bridge between proof terms and theorems, provided by the Curry-Howard isomorphism, and derive step-by-step an efficient algorithm requiring a low polynomial effort per generated theorem. The resulting Prolog program runs in O(N) space for terms of size N and generates in a few hours 7,566,084,686 theorems in the implicational fragment of Linear Intuitionistic Logic together with their proof terms in normal form. As applications, we generate datasets for correctness and scalability testing of linear logic theorem provers and training data for neural networks working on theorem proving challenges. The results in the paper, organized as a literate Prolog program, are fully replicable. Keywords: combinatorial generation of provable formulas of a given size, intuitionistic and linear logic theorem provers, theorems of the implicational fragment of propositional linear intuitionistic logic, Curry-Howard isomorphism, efficient generation of linear lambda terms in normal form, Prolog programs for lambda term generation and theorem proving.