Weighted graphs: A tool for studying the halting problem and time complexity in term rewriting systems and logic programming

In the past years, analyzers have been introduced to detect classes of non-terminating queries for definite logic programs. Although these non-termination analyzers have shown to be rather precise, their applicability on real-life Prolog programs is limited because most Prolog programs use non-logical features. As a first step towards the analysis of Prolog programs, this paper presents a non-termination condition for Logic Programs containing integer arithmetics. The analyzer is based on our non-termination analyzer presented at International Logic Programming Conference (ICLP) 2009. The analysis starts from a class of queries and infers a subclass of non-terminating ones. In first phase, we ignore the outcome (success or failure) of the arithmetic operations, assuming success of all arithmetic calls. In second phase, we characterize successful arithmetic calls as a constraint problem, the solution of which determines the non-terminating queries.

We present a logic programming language where both problem domain and computational knowledge are expressed in logic. A logic program in this language consists of an object-program and a number of meta-programs. The object program, a collection of formulae, is a description of the problem domain of interest. The meta-programs, also just collections of formulae, specify desired computational behaviours. The object-program and meta-programs are compiled together to produce a single, efficient procedural logic (Prolog) program.

The problem of learning logical rules from examples arises in diverse fields, including program synthesis, logic programming, and machine learning. Existing approaches either involve solving computationally difficult combinatorial problems, or performing parameter estimation in complex statistical models. In this paper, we present Difflog, a technique to extend the logic programming language Datalog to the continuous setting. By attaching real-valued weights to individual rules of a Datalog program, we naturally associate numerical values with individual conclusions of the program. Analogous to the strategy of numerical relaxation in optimization problems, we can now first determine the rule weights which cause the best agreement between the training labels and the induced values of output tuples, and subsequently recover the classical discrete-valued target program from the continuous optimum. We evaluate Difflog on a suite of 34~benchmark problems from recent literature in knowledge discovery, formal verification, and database query-by-example, and demonstrate significant improvements in learning complex programs with recursive rules, invented predicates, and relations of arbitrary arity.

Given a logic program P, the operator TP associated with P is closely related to the intended meaning of P. Given a first order language L that is generated by finitely many non-logical symbols, our aim is to study the algebraic properties of the set {TP|P is a general logic program in language L} with certain operators on it. For the operators defined in this paper the resulting algebraic structure is a bounded distributive lattice. Our study extends (to the case of general logic programs), the work of Mancarella and Pedreschi who initiated a study of the algebraic properties of the space of pure logic programs. We study the algebraic properties of this set and identify the ideals and zero divisors. In addition, we prove that our algebra satisfies various non-extensibility conditions.

We present a system for visualization and interaction with Prolog programs using a structural editing approach, that may be extended to other logic languages since it is based in concepts from the Logic Programming (LP) paradigm.KeywordsLogic ProgramLogic ProgrammingPartial EvaluationContext Free GrammarLogic LanguageThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Logic programming is a language paradigm based on logic, more specifically on resolution theorem proving in the predicate calculus as proposed in Robinson [1965]. Robinson had the foresight to distinguish the importance of two components in automatic theorem proving: a single inference rule called resolution and the testing for equality of trees called unification. Resolution is an inference step used to prove the validity of predicate calculus formulas expressed as clauses. In its simplest version: P ~ Q and -P ~ R imply Q ~ R, which is called the resolvant. Unification is the matching of terms used in a resolution step. It consists of testing the satisfiability of the equality of terms (i.e., labeled trees) whose leaves may contain variables. For example, the unification of the terms p(X, q(Z, a)) and p(b, q(a, Y)) succeeds, yielding the bindings X 5 b, Z 5 a, and Y 5 a. Prolog, the main representative of LP, consists of a sequence of Horn clauses. A Horn clause is one containing (at most) one positive literal. The term definite clause is used to denote a clause with exactly one positive literal. Prolog programs can be viewed as a set of definite clauses in which the positive literal is the head of the rule and the negative literals constitute the body or tail of the rule. From a procedural point of view, a head corresponds to the definition of a Boolean function whose body consists of conjunctions of calls to the Boolean functions representing the tail [Kowalski 1979]. A quintessential example of a Prolog program is that of append. It consists of two Horn clauses specifying that list L3 is the concatenation of two lists, L1 and L2:

Generic programming is likely to become a new challenge for a critical mass of developers. Therefore, it is crucial to refine the support for generic programming in mainstream Object-Oriented languages — both at the design and at the implementation level — as well as to suggest novel ways to exploit the additional degree of expressiveness made available by genericity. This study is meant to provide a contribution towards bringing Java genericity to a more mature stage with respect to mainstream programming practice, by increasing the effectiveness of its implementation, and by revealing its full expressive power in real world scenario. With respect to the current research setting, the main contribution of the thesis is twofold. First, we propose a revised implementation for Java generics that greatly increases the expressiveness of the Java platform by adding reification support for generic types. Secondly, we show how Java genericity can be leveraged in a real world case-study in the context of the multi-paradigm language integration. Several approaches have been proposed in order to overcome the lack of reification of generic types in the Java programming language. Existing approaches tackle the problem of reification of generic types by defining new translation techniques which would allow for a runtime representation of generics and wildcards. Unfortunately most approaches suffer from several problems: heterogeneous translations are known to be problematic when considering reification of generic methods and wildcards. On the other hand, more sophisticated techniques requiring changes in the Java runtime, supports reified generics through a true language extension (where clauses) so that backward compatibility is compromised. In this thesis we develop a sophisticated type-passing technique for addressing the problem of reification of generic types in the Java programming language; this approach — first pioneered by the so called EGO translator — is here turned into a full-blown solution which reifies generic types inside the Java Virtual Machine (JVM) itself, thus overcoming both performance penalties and compatibility issues of the original EGO translator. Java-Prolog integration Integrating Object-Oriented and declarative programming has been the subject of several researches and corresponding technologies. Such proposals come in two flavours, either attempting at joining the two paradigms, or simply providing an interface library for accessing Prolog declarative features from a mainstream Object-Oriented languages such as Java. Both solutions have however drawbacks: in the case of hybrid languages featuring both Object-Oriented and logic traits, such resulting language is typically too complex, thus making mainstream application development an harder task; in the case of library-based integration approaches there is no true language integration, and some “boilerplate code” has to be implemented to fix the paradigm mismatch. In this thesis we develop a framework called PatJ which promotes seamless exploitation of Prolog programming in Java. A sophisticated usage of generics/wildcards allows to define a precise mapping between Object-Oriented and declarative features. PatJ defines a hierarchy of classes where the bidirectional semantics of Prolog terms is modelled directly at the level of the Java generic type-system.

In this chapter we analyse the other paradigm which, together with functional programming, supports declarative programming. The logic programming paradigm includes both theoretical and fully implemented languages, of which the best known is surely PROLOG. Even if there are big differences of a pragmatic and, for some, a theoretical nature between these languages, they all share the idea of interpreting computation as logical deduction. In this chapter, we will therefore examine these concepts while trying to limit the theoretical part. We also adopt the approach that has characterised the rest of the text while examining this paradigm. We do not mean therefore to teach programming in PROLOG, even if we present various examples of real programs, but we do intend to provide enough basis for understanding and, in a short time, mastering this and other logic programming languages.

Prolog programming for artificial intelligence: Ivan Bratko, Addison Wesley Publishing Company (1986)

With a number of access rules at play along with contexts in which they may or may not apply, it is not always obvious to the legitimate user what caused an authorization server to deny a request, neither is it possible for the administrator to specify a complete fail proof policy. It then becomes the responsibility of the system to act in a user friendly manner by providing feedback suggesting the requester about possible alternatives. The system should also cover any unhandled request that it may encounter due to an incomplete system policy. At the same time, it is essential for feedback to not reveal the entire policy to any user. In this paper we propose a framework Cue, for generating feedback in XACML using logic programming in Prolog. Feedback content is protected by the use of meta policy which itself is specified in XACML. We first translate XACML policies into logic based functors. Second, we execute a query using parameters in the denied XACML request, to identify conditions that failed. Third, the failed condition is notified as feedback if a meta policy allows the system to reveal it. Cue is capable of generating appropriate feedback while ensuring that a desired degree of confidentiality is maintained.

Logic programming in Prolog

Connectivity related concepts are of fundamental interest in graph theory. The area has received extensive attention over four decades, but many problems remain unsolved, especially for directed graphs. A directed graph is 2-edge-connected (resp., 2-vertex-connected) if the removal of any edge (resp., vertex) leaves the graph strongly connected. In this paper we present improved algorithms for computing the maximal 2-edge- and 2-vertex-connected subgraphs of a given directed graph. These problems were first studied more than 35 years ago, with O(mn) time algorithms for graphs with m edges and n vertices being known since the late 1980s. In contrast, the same problems for undirected graphs are known to be solvable in linear time. Henzinger et al. [ICALP 2015] recently introduced O(n2) time algorithms for the directed case, thus improving the running times for dense graphs. Our new algorithms run in time O(m3/2), which further improves the running times for sparse graphs.The notion of 2-connectivity naturally generalizes to k-connectivity for k > 2. For constant values of k, we extend one of our algorithms to compute the maximal k-edge-connected in time O(m3/2 log n), improving again for sparse graphs the best known algorithm by Henzinger et al. [ICALP 2015] that runs in O(n2 log n) time.

Our purpose is to develop a modular systematic method of representing nonmonotonic reasoning problems with the Well Founded Semantics of extended logic programs augmented with eXplicit negation (WFSX), and augmented by its Contradiction Removal Semantics (CRSX) when needed. We show how to cast in the language of such logic programs forms of non-monotonic reasoning like defeasible reasoning and hypothetical reasoning, and apply them to different domains of knowledge representation, for instance taxonomic hierarchies and reasoning about actions. We then abstract a modular systematic method of representing non-monotonic problems in logic programming.

This paper has proposed a classification rule base mining algorithm combining the genetic algorithm and intuitionistic fuzzy-rough set for large-scale intuitionistic fuzzy information system. The algorithm has proposed innovatively the definitions and measurement metrics of completeness, interaction and compatibility describing the whole rule base, and constructed a multi-objective optimization model to optimize the population size of data sample, and used the intuitionistic fuzzy-rough set to reduce the attribute set of fuzzy information system, and used intuitionistic fuzzy similar class to extract large-scale intuitionistic fuzzy information system rules, and obtained an optimal rule base with the minimal size, configuration, generation time and storage space. A threshold control mechanism is used to evaluate the completeness, interaction and correlation of rule population and improves the robustness and flexibility of sample population optimization and rule base generation. The algorithm is verified by the real aircraft health data sets. The algorithm is validated by similar mature and effective algorithms in accuracy, time complexity using real data and has good robustness and adaptability to different size large-scale fuzzy information system.

Although the SLD paradigm is theoretically adequate for all computational purposes, the pure Horn-clause language on which it is based is unlikely to become the dominant logic-programming language of the future. In fact it never has been the mainstream logic-programming language, as every Prolog programmer will testify-writing a logic program for a real-world application nearly always seems to require the expression of some intention or other for which there is apparently no practical representation in pure Horn-clause logic. It is futile to resist this fact of computational life; in the end, the cumulative and collective experience of serious practitioners has to be respected. The designers of Prolog anticipated this and consequently felt obliged to add many non-logical extensions to the Horn-clause kernel. In doing so they placed greater weight upon the concrete needs of the practitioners than upon the more abstract desires of the theoreticians. A lot of research effort has since been devoted to the problem of rendering those extensions either semantically intelligible or methodologically redundant. A substantial part of that effort has concentrated upon one particular issue-the finite failure extension.