Prolog Rules Research Articles

CON-FOLD Explainable Machine Learning with Confidence

Abstract FOLD-RM is an explainable machine learning classification algorithm that uses training data to create a set of classification rules. In this paper, we introduce CON-FOLD which extends FOLD-RM in several ways. CON-FOLD assigns probability-based confidence scores to rules learned for a classification task. This allows users to know how confident they should be in a prediction made by the model. We present a confidence-based pruning algorithm that uses the unique structure of FOLD-RM rules to efficiently prune rules and prevent overfitting. Furthermore, CON-FOLD enables the user to provide preexisting knowledge in the form of logic program rules that are either (fixed) background knowledge or (modifiable) initial rule candidates. The paper describes our method in detail and reports on practical experiments. We demonstrate the performance of the algorithm on benchmark datasets from the UCI Machine Learning Repository. For that, we introduce a new metric, Inverse Brier Score, to evaluate the accuracy of the produced confidence scores. Finally, we apply this extension to a real-world example that requires explainability: marking of student responses to a short answer question from the Australian Physics Olympiad.

Untying black boxes with clustering-based symbolic knowledge extraction

Machine learning black boxes, exemplified by deep neural networks, often exhibit challenges in interpretability due to their reliance on complicated relationships involving numerous internal parameters and input features. This lack of transparency from a human perspective renders their predictions untrustworthy, particularly in critical applications. In this paper, we address this issue by introducing the design and implementation of CReEPy, an algorithm for symbolic knowledge extraction based on explainable clustering. Specifically, CReEPy leverages the underlying clustering performed by the ExACT or CREAM algorithms to generate human-interpretable Prolog rules that mimic the behaviour of opaque models. Additionally, we introduce CRASH, an algorithm for the automated tuning of hyper-parameters required by CReEPy. We present experiments evaluating both the human readability and predictive performance of the proposed knowledge-extraction algorithm, employing existing state-of-the-art techniques as benchmarks for comparison in real-world applications.

Symbolic knowledge extraction for explainable nutritional recommenders

Background and objective:This paper focuses on nutritional recommendation systems (RS), i.e. AI-powered automatic systems providing users with suggestions about what to eat to pursue their weight/body shape goals. A trade-off among (potentially) conflictual requirements must be taken into account when designing these kinds of systems, there including: (i) adherence to experts’ prescriptions, (ii) adherence to users’ tastes and preferences, (iii) explainability of the whole recommendation process. Accordingly, in this paper we propose a novel approach to the engineering of nutritional RS, combining machine learning and symbolic knowledge extraction to profile users—hence harmonising the aforementioned requirements.MethodsOur contribution focuses on the data processing workflow. Stemming from neural networks (NN) trained to predict user preferences, we use CART Breiman et al.(1984) to extract symbolic rules in Prolog Körner et al.(2022) form, and we combine them with expert prescriptions brought in similar form. We can then query the resulting symbolic knowledge base via logic solvers, to draw explainable recommendations.ResultsExperiments are performed involving a publicly available dataset of 45,723 recipes, plus 12 synthetic datasets about as many imaginary users, and 6 experts’ prescriptions. Fully-connected 4-layered NN are trained on those datasets, reaching ∼86% test-set accuracy, on average. Extracted rules, in turn, have ∼80% fidelity w.r.t. those NN. The resulting recommendation system has a test-set precision of ∼74%. The symbolic approach makes it possible to devise how the system draws recommendations.ConclusionsThanks to our approach, intelligent agents may learn users’ preferences from data, convert them into symbolic form, and extend them with experts’ goal-directed prescriptions. The resulting recommendations are then simultaneously acceptable for the end user and adequate under a nutritional perspective, while the whole process of recommendation generation is made explainable.

Prolog-based agnostic explanation module for structured pattern classification

This paper presents a Prolog-based reasoning module to generate counterfactual explanations given the predictions computed by a black-box classifier. Our approach comprises four well-defined stages that can be applied to any structured pattern classification problem. Firstly, we pre-process the given dataset by imputing missing values and normalizing the numerical features. Secondly, we transform numerical features into symbolic ones using fuzzy clustering such that extracted fuzzy clusters are mapped to an ordered set of predefined symbols. Thirdly, we encode instances as a Prolog rule using the nominal values, the predefined symbols, the decision classes, and the confidence values. Fourthly, we compute the overall confidence of each Prolog rule using fuzzy-rough set theory to handle the uncertainty caused by transforming numerical quantities into symbols. This step comes with an additional theoretical contribution to a new similarity function to compare the previously defined Prolog rules involving confidence values. Finally, we implement a chatbot as a proxy between humans and the Prolog-based reasoning module to resolve natural language queries and generate counterfactual explanations. During the numerical simulations using synthetic datasets, we study the performance of our system when using different fuzzy operators and similarity functions.

From User Stories to UML Diagrams Driven by Ontological and Production Model

The User Story format has become the most popular way of expressing requirements in Agile methods. However, a requirement does not state how a solution will be physically achieved. The purpose of this paper is to present a new approach that automatically transforms user stories into UML diagrams. Our approach aims to automatically generate UML diagrams, namely class, use cases, and package diagrams. User stories are written in natural language (English), so the use of a natural language processing tool was necessary for their processing. In our case, we have used Stanford core NLP. The automation approach consists of the combination of rules formulated as a predicate and an ontological model. Prolog rules are used to extract relationships between classes and eliminate those that are at risk of error. To extract the design elements, the prolog rules used dependencies offered by Stanford core NLP. An ontology representing the components of the user stories was created to identify equivalent relationships and inclusion use cases. The tool developed was implemented in the Python programming language and has been validated by several case studies.

Lpopt: A Rule Optimization Tool for Answer Set Programming

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 handtuning 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.

Reasoning about the disruption patterns for train system using Bayesian Network and Prolog

We construct a Prolog-based expert system to reason about the disruption patterns for train system using Bayesian network and Prolog. The disruptions dependencies are modeled using Bayesian network and the reasoning is carried on using Prolog. We choose Bayesian network because it is one of the most efficient and elegant framework to represent and reason probabilistic graphical model. The causative relationship among disruptions is represented using Directed Acyclic Graph (DAG). We use Prolog to improve the efficiency of the reasoning process by defining Bayesian network and its probabilistic information into a knowledge base. The causative relationships among disruptions are also modeled in terms of Prolog rules. Our Prolog-based expert system combines the statistical reasoning capability of Bayesian network and logic programming efficiency. The system provides comprehensive reasoning regarding the causative probability of events, the causative relationship among disruptions, as well as the most triggering and triggered disruptions in train system.

Top-down and Bottom-up Evaluation Procedurally Integrated

AbstractThis paper describes how the Logic Programming System XSB combines top-down and bottom-up computation through the mechanisms of variant tabling and subsumptive tabling with abstraction, respectively.It is well known that top-down evaluation of logical rules in Prolog has a procedural interpretation as recursive procedure invocation (Kowalski 1986). Tabling adds the intuition of short-circuiting redundant computations (Warren 1992). This paper shows how to introduce into tabled logic program evaluation a bottom-up component, whose procedural intuition is the initialization of a data structure, in which a relation is initially computed and filled, on first demand, and then used throughout the remainder of a larger computation for efficient lookup. This allows many Prolog programs to be expressed fully declaratively, programs which formerly required procedural features, such as assert, to be made efficient.

Temporal constrained objects: Application and implementation

We present a novel programming concept called temporal constrained objects for modeling of dynamic systems. It is an extension of the paradigm of constrained objects which provides a principled approach to modeling complex engineering systems based upon two main principles: a compositional specification of the structure of the system, using objects, and a declarative specification of its behavior, using constraints. A novel feature of temporal constrained objects is the series variable, the sequence of whose values is determined by constraints that include metric temporal operators. The emergent behavior of a dynamic system is determined through a process of time-based simulation and constraint satisfaction at each step. Each class definition for a temporal constrained object is translated into a Prolog rule with constraint-solving capability. In order to improve the performance for long simulations, a partial evaluation technique is adopted for optimized code generation. This paper describes the syntax of a language called TCOB along with several examples, our objective being to demonstrate the benefits of the programming paradigm. TCOB has been implemented and all examples presented in this paper were tested using this implementation. An overview of the translation as well as partial execution and its performance improvements are presented in the paper.

Introduction to the special issue on the International Web Rule Symposia 2012–2014

The annual International Web Rule Symposium (RuleML) is an international conference on research, applications, languages, and standards for rule technologies. It has evolved from an annual series of international workshops since 2002, international conferences in 2005 and 2006, and international symposia since 2007. It is the flagship event of the Rule Markup and Modeling Initiative (RuleML, http://ruleml.org), a nonprofit umbrella organization of several technical groups from academia, industry, and government working on rule technology and its applications. RuleML is the leading conference to build bridges between academia and industry in the field of rules and its applications, especially as part of the semantic technology stack. It is devoted to rule-based programming and rule-based systems including production rules systems, logic programming rule engines, and business rules engines/business rules management systems; Semantic Web rule languages and rule standards (e.g., RuleML, SWRL, RIF, PRR, SBVR, DMN, CL, Prolog); rule-based event processing languages and technologies; and research on inference rules, transformation rules, decision rules, production rules, and ECA rules.

A Report on the Ninth International Web Rule Symposium

The annual International Web Rule Symposium (RuleML) is an international conference on research, applications, languages, and standards for rule technologies. RuleML is a leading conference to build bridges between academe and industry in the field of rules and its applications, especially as part of the semantic technology stack. It is devoted to rule‐based programming and rule‐based systems including production rules systems, logic programming rule engines, and business rule engines/business rule management systems; semantic web rule languages and rule standards; rule‐based event‐processing languages (EPLs) and technologies; and research on inference rules, transformation rules, decision rules, production rules, and ECA rules. The Ninth International Web Rule Symposium (RuleML 2015) was held in Berlin, Germany, August 2–5. This report summarizes the events of that conference.

PTL: A model transformation language based on logic programming

In this paper we present a model transformation language based on logic programming. The language, called PTL (Prolog based Transformation Language), can be considered as a hybrid language in which ATL (Atlas Transformation Language)-style rules are combined with logic rules for defining transformations. ATL-style rules are used to define mappings from source models to target models while logic rules are used as helpers. The implementation of PTL is based on the encoding of the ATL-style rules by Prolog rules. Thus, PTL makes use of Prolog as a transformation engine. We have provided a declarative semantics to PTL and proved the semantics equivalent to the encoded program. We have studied an encoding of OCL (Object Constraint Language) with Prolog goals in order to map ATL to PTL. Thus a subset of PTL can be considered equivalent to a subset of ATL. The proposed language can be also used for model validation, that is, for checking constraints on models and transformations. We have equipped our language with debugging and tracing capabilities which help developers to detect programming errors in PTL rules. Additionally, we have developed an Eclipse plugin for editing PTL programs, as well as for debugging, tracing and validation. Finally, we have evaluated the language with several transformation examples as well as tested the performance with large models.

Formal Description of Arabic Syntactic Structure in the Framework of the Government and Binding Theory

The research focus in our paper is twofold: (a) to examine the extent to which simple Arabic sentence structures comply with the Government and Binding Theory (GB), and (b) to implement a simple Arabic Context Free Grammar (CFG) parser to analyze input sentence structures to improve some Arabic Natural Language Processing (ANLP) Applications. Here we present a parser that employs Chomsky's Government and Binding (GB) theory to better understand the syntactic structure of Arabic sentences. We consider different simple word orders in Arabic and show how they are derived. We analyze different sentence orders including Subject-Verb-Object (SVO), Verb-Object-Subject (VOS), Verb-Subject-Object (VSO), nominal sentences, nominal sentences beginning with inna (and sisters) and question sentences. We tackle the analysis of the structures to develop syntactic rules for a fragment of Arabic grammar. We include two sets of rules: (1) rules on sentence structures that do not account for case and (2) rules on sentence structures that account for case of Noun Phrases (NPs). We present an implementation of the grammar rules in Prolog. The experiments revealed high accuracy in case assignment in Modern Standard Arabic (MSA) in the light of GB theory especially when the input sentences are tagged with identification of end cases.

Monotonic qualitative logic programs: Computation and applications

A qualitative logic program QLP is a logic program where a dominance is associated with each rule in the program. The intuition is that rules with higher dominance are more plausible or more reliable. Literals in the answer sets of QLPs are also annotated with weights, with the intuition that a literal with a higher weight is more likely to be true. We present three different applications of QLPs: Ontology Matching, Ranking of search results and Inheritance Networks. We also address the problem of computing answer sets of QLPs. We define a property of QLPs called “monotonicity” and show that answer sets of monotonic QLPs can be computed in an “anytime” fashion, such that the literals are produced by a descending order of their dominance. We then present an application of QLP called LPmatch, which is a tool for ontology matching. LPmatch is a simple matcher composed of only nineteen logic programming rules. The most significant advantage of LPmatch is its flexibility as it can handle new domains for ontology matching instantly just by adding new rules. Comparisons with other existing tools show that LPmatch is a top performer.

On constructing intellectual systems in ternary logic

The paper shows that it is possible to develop an intelligent system on a production knowledge model using three-valued logic, which operates with the states "truth, false, possible". A method is proposed for constructing intelligent systems that are free from contradictions and are capable of not only extracting facts but also explaining what facts are needed to achieve the goal. Examples of ternary Prolog rules are given.

Compiling Input* FO(·) inductive definitions into tabled prolog rules for IDP3

AbstractFO(·)IDP3extends first-order logic with inductive definitions, partial functions, types and aggregates. Its model generator IDP3 first grounds the theory and then uses search to find the models. The grounder uses Lifted Unit Propagation (LUP) to reduce the size of the groundings of problem specifications in IDP3. LUP is in general very effective, but performs poorly on definitions of predicates whose two-valued interpretation can be computed from data in the input structure. To solve this problem, a preprocessing step is introduced that converts such definitions to Prolog code and usesXSBProlog to compute their interpretation. The interpretation of these predicates is then added to the input structure, their definitions are removed from the theory and further processing is done by the standard IDP3 system. Experimental results show the effectiveness of our method.

Lightweight string reasoning in model finding

Models play a key role in assuring software quality in the model-driven approach. Precise models usually require the definition of well-formedness rules to specify constraints that cannot be expressed graphically. The Object Constraint Language (OCL) is a de-facto standard to define such rules. Techniques that check the satisfiability of such models and find corresponding instances of them are important in various activities, such as model-based testing and validation. Several tools for these activities have been developed, but to our knowledge, none of them supports OCL string operations on scale that is sufficient for, e.g., model-based testing. As, in contrast, many industrial models do contain such operations, there is evidently a gap. We present a lightweight solver that is specifically tailored to generate large solutions for tractable string constraints in model finding, and that is suited to directly express the main operations of the OCL datatype String. It is based on constraint logic programming (CLP) and constraint handling rules, and can be seamlessly combined with other constraint solvers in CLP. We have integrated our solver into the EMFtoCSP model finder, and we show that our implementation efficiently solves several common string constraints on large instances.

Provenance and Temporally Annotated Logic Programming

In this paper, we consider provenance and temporally annotated logic rules (pt-logic rules, for short), which are definite logic programming rules associated with the name of the source that they originate and the temporal interval during which they are valid. A collection of pt-logic rules form a provenance and temporally annotated logic program P, called pt-logic program, for short. We develop a model theory for P and define its maximally temporal entailments of the form A:<S, ti>, indicating that atom A is derived from a set of sources S and holds at a maximal temporal interval ti, according to S. We define a consequence operator that derives exactly the maximally temporal entailments of P for a set of sources. We show that the complexity of the considered entailment is EXPTIME-complete.

Ontology and medical diagnosis

Ontology and associated generic tools are appropriate for knowledge modeling and reasoning, but most of the time, disease definitions in existing description logic (DL) ontology are not sufficient to classify patient's characteristics under a particular disease because they do not formalize operational definitions of diseases (association of signs and symptoms = diagnostic criteria). The main objective of this study is to propose an ontological representation which takes into account the diagnostic criteria on which specific patient conditions may be classified under a specific disease. This method needs as a prerequisite a clear list of necessary and sufficient diagnostic criteria as defined for lots of diseases by learned societies. It does not include probability/uncertainty which Web Ontology Language (OWL 2.0) cannot handle. We illustrate it with spondyloarthritis (SpA). Ontology has been designed in Protégé 4.1 OWL-DL2.0. Several kinds of criteria were formalized: (1) mandatory criteria, (2) picking two criteria among several diagnostic criteria, (3) numeric criteria. Thirty real patient cases were successfully classified with the reasoner. This study shows that it is possible to represent operational definitions of diseases with OWL and successfully classify real patient cases. Representing diagnostic criteria as descriptive knowledge (instead of rules in Semantic Web Rule Language or Prolog) allows us to take advantage of tools already available for OWL. While we focused on Assessment of SpondyloArthritis international Society SpA criteria, we believe that many of the representation issues addressed here are relevant to using OWL-DL for operational definition of other diseases in ontology.

Approximation of action theories and its application to conformant planning

This paper describes our methodology for building conformant planners, which is based on recent advances in the theory of action and change and answer set programming. The development of a planner for a given dynamic domain starts with encoding the knowledge about fluents and actions of the domain as an action theory D of some action language. Our choice in this paper is AL – an action language with dynamic and static causal laws and executability conditions. An action theory D of AL defines a transition diagram T ( D ) containing all the possible trajectories of the domain. A transition 〈 s , a , s ′ 〉 belongs to T ( D ) iff the execution of the action a in the state s may move the domain to the state s ′ . The second step in the planner development consists in finding a deterministic transition diagram T l p ( D ) such that nodes of T l p ( D ) are partial states of D , its arcs are labeled by actions, and a path in T l p ( D ) from an initial partial state δ 0 to a partial state satisfying the goal δ f corresponds to a conformant plan for δ 0 and δ f in T ( D ) . The transition diagram T l p ( D ) is called an ‘approximation’ of T ( D ) . We claim that a concise description of an approximation of T ( D ) can often be given by a logic program π ( D ) under the answer sets semantics. Moreover, complex initial situations and constraints on plans can be also expressed by logic programming rules and included in π ( D ) . If this is possible then the problem of finding a parallel or sequential conformant plan can be reduced to computing answer sets of π ( D ) . This can be done by general purpose answer set solvers. If plans are sequential and long then this method can be too time consuming. In this case, π ( D ) is used as a specification for a procedural graph searching conformant planning algorithm. The paper illustrates this methodology by building several conformant planners which work for domains with complex relationship between the fluents. The efficiency of the planners is experimentally evaluated on a number of new and old benchmarks. In addition we show that for a subclass of action theories of AL our planners are complete, i.e., if in T l p ( D ) we cannot get from δ 0 to a state satisfying the goal δ f then there is no conformant plan for δ 0 and δ f in T ( D ) .