Downloads & Free Reading Options - Results

xviii, 184 pages ; 24 cm

45 p. 28 cm

45 p. 28 cm

The Journal of Logic Programming 1985: Volume 2 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1985_2_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1985-04_2_1 .

The 'Language Studies' contract is divided into four project areas, all of which are directed to the problems of effectively, reliably and efficiently using modern computers in a wide range of applications. Three of the projects deal with methods of communicating with computers. Task 1. Very High Level Programming Systems (P.I: J. A. Robinson). This group is working towards combining the features developed to support work in the area of artificial intelligence and those used in general program development into a new conceptual framework that can be understood and used by a large community of users. Task 2. Proving Program Correctness (P.I: J. C. Reynolds). This group is working towards programming language designs which increase the probability that specification errors will be detected by the compiler or interpreter and to provide the language facilities so that users will more nearly be able to prove that programs perform as they are specified than is currently possible. Task 3. Grammars of Programming (P.I: E. F. Storm). This group is working towards the development of methods which will allow users to communicate with computer programs in terms of more normal to their every day communication forms. Task 4. Systems Studies (P.I: R. G. Sargent). This group is working towards developing more sophisticated and efficient models of computer systems which can predict system performance when given particular parameter values. The current efforts concern models of transaction processing systems (TPS). (Author)

TU Dresden CMS LM Foundations of Logic Programming Exam 2021-2022

Event recognition systems rely on properly engineered knowledge bases of event definitions to infer occurrences of events in time. The manual development of such knowledge is a tedious and error-prone task, thus event-based applications may benefit from automated knowledge construction techniques, such as Inductive Logic Programming (ILP), which combines machine learning with the declarative and formal semantics of First-Order Logic. However, learning temporal logical formalisms, which are typically utilized by logic-based Event Recognition systems is a challenging task, which most ILP systems cannot fully undertake. In addition, event-based data is usually massive and collected at different times and under various circumstances. Ideally, systems that learn from temporal data should be able to operate in an incremental mode, that is, revise prior constructed knowledge in the face of new evidence. Most ILP systems are batch learners, in the sense that in order to account for new evidence they have no alternative but to forget past knowledge and learn from scratch. Given the increased inherent complexity of ILP and the volumes of real-life temporal data, this results to algorithms that scale poorly. In this work we present an incremental method for learning and revising event-based knowledge, in the form of Event Calculus programs. The proposed algorithm relies on abductive-inductive learning and comprises a scalable clause refinement methodology, based on a compressive summarization of clause coverage in a stream of examples. We present an empirical evaluation of our approach on real and synthetic data from activity recognition and city transport applications.

Software testing is one of the most popular validation techniques in the software industry. Surprisingly, we can only find a few approaches to testing in the context of logic programming. In this paper, we introduce a systematic approach for dynamic testing that combines both concrete and symbolic execution. Our approach is fully automatic and guarantees full path coverage when it terminates. We prove some basic properties of our technique and illustrate its practical usefulness through a prototype implementation.

Constraint Logic Programming (CLP) and Hereditary Harrop formulas (HH) are two well known ways to enhance the expressivity of Horn clauses. In this paper, we present a novel combination of these two approaches. We show how to enrich the syntax and proof theory of HH with the help of a given constraint system, in such a way that the key property of HH as a logic programming language (namely, the existence of uniform proofs) is preserved. We also present a procedure for goal solving, showing its soundness and completeness for computing answer constraints. As a consequence of this result, we obtain a new strong completeness theorem for CLP that avoids the need to build disjunctions of computed answers, as well as a more abstract formulation of a known completeness theorem for HH.

After examining the {\bf P} versus {\bf NP} problem against the Kleene-Rosser paradox of the $\lambda$-calculus [94], it was found that it represents a counter-example to NP-completeness. We prove that it contradicts the proof of Cook's theorem. A logical formalization of the liar's paradox leads to the same result. This formalization of the liar's paradox into a computable form is a 2-valued instance of a fuzzy logic programming paradox discovered in the system of [90]. Three proofs that show that {\bf SAT} is (NOT) NP-complete are presented. The counter-example classes to NP-completeness are also counter-examples to Fagin's theorem [36] and the Immermann-Vardi theorem [89,110], the fundamental results of descriptive complexity. All these results show that {\bf ZF$\not$C} is inconsistent.

The aim of the Alma project is the design of a strongly typed constraint programming language that combines the advantages of logic and imperative programming. The first stage of the project was the design and implementation of Alma-0, a small programming language that provides a support for declarative programming within the imperative programming framework. It is obtained by extending a subset of Modula-2 by a small number of features inspired by the logic programming paradigm. In this paper we discuss the rationale for the design of Alma-0, the benefits of the resulting hybrid programming framework, and the current work on adding constraint processing capabilities to the language. In particular, we discuss the role of the logical and customary variables, the interaction between the constraint store and the program, and the need for lists.

We study conditions for a concurrent construction of proof-nets in the framework developed by Andreoli in recent papers. We define specific correctness criteria for that purpose. We first study closed modules (i.e. validity of the execution of a logic program), then extend the criterion to open modules (i.e. validity during the execution) distinguishing criteria for acyclicity and connectability in order to allow incremental verification.

We study conditions for a concurrent construction of proof-nets in the framework developed by Andreoli in recent papers. We define specific correctness criteria for that purpose. We first study closed modules (i.e. validity of the execution of a logic program), then extend the criterion to open modules (i.e. validity during the execution) distinguishing criteria for acyclicity and connectability in order to allow incremental verification.

The Northeast Artificial Intelligence Consortium (NAIC) was created to conduct pertinent research in artificial intelligence and to perform activities ancillary to this research. The topics covered in general are: versatile expert system for equipment maintenance, distributed AI for communications system control, automatic photo interpretation, time-oriented problem solving, speech understanding systems, knowledge base maintenance, hardware architectures for very large systems, knowledge-based reasoning and planning, and a knowledge acquisition, assistance, and explanation system. The specific topic for this volume is the use of logic programming methodologies for knowledge base maintenance. Keywords: Artificial intelligence, Prolog, Knowledge base, Logic programming, Languages, Feasibility, Knowledge base maintenance.

This paper describes a method of program construction that combines some contributions in structured programming, program verification and program synthesis. This method has start-to-finish continuity within mathematical logic. (Author)

This paper describes a method of program construction that combines some contributions in structured programming, program verification and program synthesis. This method has start-to-finish continuity within mathematical logic. (Author)

This paper describes a method of program construction that combines some contributions in structured programming, program verification and program synthesis. This method has start-to-finish continuity within mathematical logic. (Author)

This paper describes a method of program construction that combines some contributions in structured programming, program verification and program synthesis. This method has start-to-finish continuity within mathematical logic. (Author)

Automated analysis of recursive derivations in logic programming is known to be a hard problem. Both termination and non-termination are undecidable problems in Turing-complete languages. However, some declarative languages offer a practical work-around for this problem, by making a clear distinction between whether a program is meant to be understood inductively or coinductively. For programs meant to be understood inductively, termination must be guaranteed, whereas for programs meant to be understood coinductively, productive non-termination (or "productivity") must be ensured. In practice, such classification helps to better understand and implement some non-terminating computations. Logic programming was one of the first declarative languages to make this distinction: in the 1980's, Lloyd and van Emden's "computations at infinity" captured the big-step operational semantics of derivations that produce infinite terms as answers. In modern terms, computations at infinity describe "global productivity" of computations in logic programming. Most programming languages featuring coinduction also provide an observational, or small-step, notion of productivity as a computational counterpart to global productivity. This kind of productivity is ensured by checking that finite initial fragments of infinite computations can always be observed to produce finite portions of their infinite answer terms. In this paper we introduce a notion of observational productivity for logic programming as an algorithmic approximation of global productivity, give an effective procedure for semi-deciding observational productivity, and offer an implemented automated observational productivity checker for logic programs.

Automated analysis of recursive derivations in logic programming is known to be a hard problem. Both termination and non-termination are undecidable problems in Turing-complete languages. However, some declarative languages offer a practical work-around for this problem, by making a clear distinction between whether a program is meant to be understood inductively or coinductively. For programs meant to be understood inductively, termination must be guaranteed, whereas for programs meant to be understood coinductively, productive non-termination (or "productivity") must be ensured. In practice, such classification helps to better understand and implement some non-terminating computations. Logic programming was one of the first declarative languages to make this distinction: in the 1980's, Lloyd and van Emden's "computations at infinity" captured the big-step operational semantics of derivations that produce infinite terms as answers. In modern terms, computations at infinity describe "global productivity" of computations in logic programming. Most programming languages featuring coinduction also provide an observational, or small-step, notion of productivity as a computational counterpart to global productivity. This kind of productivity is ensured by checking that finite initial fragments of infinite computations can always be observed to produce finite portions of their infinite answer terms. In this paper we introduce a notion of observational productivity for logic programming as an algorithmic approximation of global productivity, give an effective procedure for semi-deciding observational productivity, and offer an implemented automated observational productivity checker for logic programs.

The purpose of this letter is to discuss our research into parallel systems software and hardware, and parallel problem solving. Under the current grant, a detailed design and partial implementation of a parallel problem solving system, PRISM (parallel inference system), based on logic was achieved. The PRISM requires that the ZMOB parallel processor be available for use. In addition, systems software and hardware have been developed. It is estimated that ZMOB will become available for use during the Fall of 1983. Hence, a full test and debugging of PRISM cannot be achieved under the current grant. At the end of the current grant we expect to have accomplished, as a minimum, all of the objectives proposed. That is, in the area of parallel problem solving, the initial PRISM has been fully designed; individual programs have been implemented and tested in a non-parallel environment; and investigations have been made into extensions to the initial design.

A technical book on something similar to lazy functional programming. It is out of print at The MIT Press, so copyright has reverted to me, the author, and I license it for free use. Steven Obua scanned a printed copy to produce this PDF version. Besides the author's work, the book acknowledges contributions by Purdue University Professor Christoph Hoffmann, Purdue University graduate students Paul Chew, Giovanni Sacco, Paul Golick, and The Johns Hopkins University graduate student Robert Strandh. After publication, The University of Chicago graduate students Samuel Rebelsky, David Sherman, Stephen Bailey, and Guanshan Tong continued work on the project. Robert Strandh and David Sherman continued the work as faculty at The University of Bordeaux.

The past few years have seen a surge of interest in the field of probabilistic logic learning and statistical relational learning. In this endeavor, many probabilistic logics have been developed. ProbLog is a recent probabilistic extension of Prolog motivated by the mining of large biological networks. In ProbLog, facts can be labeled with probabilities. These facts are treated as mutually independent random variables that indicate whether these facts belong to a randomly sampled program. Different kinds of queries can be posed to ProbLog programs. We introduce algorithms that allow the efficient execution of these queries, discuss their implementation on top of the YAP-Prolog system, and evaluate their performance in the context of large networks of biological entities.

Extensible Markup Language (XML) is a simple, very flexible text format derived from SGML. Originally designed to meet the challenges of large-scale electronic publishing, XML is also playing an increasingly important role in the exchange of a wide variety of data on the Web and elsewhere. XPath language is the result of an effort to provide address parts of an XML document. In support of this primary purpose, it becomes in a query language against an XML document. In this paper we present a proposal for the implementation of the XPath language in logic programming. With this aim we will describe the representation of XML documents by means of a logic program. Rules and facts can be used for representing the document schema and the XML document itself. In particular, we will present how to index XML documents in logic programs: rules are supposed to be stored in main memory, however facts are stored in secondary memory by using two kind of indexes: one for each XML tag, and other for each group of terminal items. In addition, we will study how to query by means of the XPath language against a logic program representing an XML document. It evolves the specialization of the logic program with regard to the XPath expression. Finally, we will also explain how to combine the indexing and the top-down evaluation of the logic program. To appear in Theory and Practice of Logic Programming (TPLP)"

In designing the interface between a database and a logic system with inference such as Prolog, efficiency is the major issue. Presented here are three of the methods that are considered most promising and in which much research is focused. The first method explores extending an inference machine to include a database manager, the second couples the inference mechanism with a database management system; and the third extends a database management mechanism to include inference. Acknowledging up front that no method can be claimed best, the major emphasis of this study will be to determine the strengths and limitations of all three methods and thereby help to clarify many uncertain and sometimes conflicting issues caused by the parallel lines of development from the database and artificial intelligence communities.

In designing the interface between a database and a logic system with inference such as Prolog, efficiency is the major issue. Presented here are three of the methods that are considered most promising and in which much research is focused. The first method explores extending an inference machine to include a database manager, the second couples the inference mechanism with a database management system; and the third extends a database management mechanism to include inference. Acknowledging up front that no method can be claimed best, the major emphasis of this study will be to determine the strengths and limitations of all three methods and thereby help to clarify many uncertain and sometimes conflicting issues caused by the parallel lines of development from the database and artificial intelligence communities.

We propose a new formal language for the expressive representation of probabilistic knowledge based on Answer Set Programming (ASP). It allows for the annotation of first-order formulas as well as ASP rules and facts with probabilities and for learning of such weights from data (parameter estimation). Weighted formulas are given a semantics in terms of soft and hard constraints which determine a probability distribution over answer sets. In contrast to related approaches, we approach inference by optionally utilizing so-called streamlining XOR constraints, in order to reduce the number of computed answer sets. Our approach is prototypically implemented. Examples illustrate the introduced concepts and point at issues and topics for future research.

Functional and Logic Programming: 5th International Symposium, FLOPS 2001 Tokyo, Japan, March 7–9, 2001 Proceedings Author: Herbert Kuchen, Kazunori Ueda Published by Springer Berlin Heidelberg ISBN: 978-3-540-41739-2 DOI: 10.1007/3-540-44716-4 Table of Contents: The Metalanguage λprolog and Its Implementation A Scalable Architecture for Proof-Carrying Code Parameterized Logic Programs where Computing Meets Learning Proving Syntactic Properties of Exceptions in an Ordered Logical Framework A Higher-Order Colon Translation Compiling Lazy Functional Programs Based on the Spineless Tagless G-machine for the Java Virtual Machine A Higher-Order Logic Programming Language with Constraints Specifying and Debugging Security Protocols via Hereditary Harrop Formulas and λProlog ‐ A Case-study ‐ An Effective Bottom-Up Semantics for First-Order Linear Logic Programs A Framework for Goal-Directed Bottom-Up Evaluation of Functional Logic Programs Theoretical Foundations for the Declarative Debugging of Lazy Functional Logic Programs Adding Linear Constraints over Real Numbers to Curry A Complete Selection Function for Lazy Conditional Narrowing An Abstract Machine Based System for a Lazy Narrowing Calculus Incremental Learning of Functional Logic Programs A General Type Inference Framework for Hindley/Milner Style Systems Monadic Encapsulation with Stack of Regions Well-Typed Logic Programs Are not Wrong A Framework for Analysis of Typed Logic Programs Abstract Compilation for Sharing Analysis

Functional and Logic Programming: 5th International Symposium, FLOPS 2001 Tokyo, Japan, March 7–9, 2001 Proceedings Author: Herbert Kuchen, Kazunori Ueda Published by Springer Berlin Heidelberg ISBN: 978-3-540-41739-2 DOI: 10.1007/3-540-44716-4 Table of Contents: The Metalanguage λprolog and Its Implementation A Scalable Architecture for Proof-Carrying Code Parameterized Logic Programs where Computing Meets Learning Proving Syntactic Properties of Exceptions in an Ordered Logical Framework A Higher-Order Colon Translation Compiling Lazy Functional Programs Based on the Spineless Tagless G-machine for the Java Virtual Machine A Higher-Order Logic Programming Language with Constraints Specifying and Debugging Security Protocols via Hereditary Harrop Formulas and λProlog ‐ A Case-study ‐ An Effective Bottom-Up Semantics for First-Order Linear Logic Programs A Framework for Goal-Directed Bottom-Up Evaluation of Functional Logic Programs Theoretical Foundations for the Declarative Debugging of Lazy Functional Logic Programs Adding Linear Constraints over Real Numbers to Curry A Complete Selection Function for Lazy Conditional Narrowing An Abstract Machine Based System for a Lazy Narrowing Calculus Incremental Learning of Functional Logic Programs A General Type Inference Framework for Hindley/Milner Style Systems Monadic Encapsulation with Stack of Regions Well-Typed Logic Programs Are not Wrong A Framework for Analysis of Typed Logic Programs Abstract Compilation for Sharing Analysis

Functional and Logic Programming: 5th International Symposium, FLOPS 2001 Tokyo, Japan, March 7–9, 2001 Proceedings Author: Herbert Kuchen, Kazunori Ueda Published by Springer Berlin Heidelberg ISBN: 978-3-540-41739-2 DOI: 10.1007/3-540-44716-4 Table of Contents: The Metalanguage λprolog and Its Implementation A Scalable Architecture for Proof-Carrying Code Parameterized Logic Programs where Computing Meets Learning Proving Syntactic Properties of Exceptions in an Ordered Logical Framework A Higher-Order Colon Translation Compiling Lazy Functional Programs Based on the Spineless Tagless G-machine for the Java Virtual Machine A Higher-Order Logic Programming Language with Constraints Specifying and Debugging Security Protocols via Hereditary Harrop Formulas and λProlog ‐ A Case-study ‐ An Effective Bottom-Up Semantics for First-Order Linear Logic Programs A Framework for Goal-Directed Bottom-Up Evaluation of Functional Logic Programs Theoretical Foundations for the Declarative Debugging of Lazy Functional Logic Programs Adding Linear Constraints over Real Numbers to Curry A Complete Selection Function for Lazy Conditional Narrowing An Abstract Machine Based System for a Lazy Narrowing Calculus Incremental Learning of Functional Logic Programs A General Type Inference Framework for Hindley/Milner Style Systems Monadic Encapsulation with Stack of Regions Well-Typed Logic Programs Are not Wrong A Framework for Analysis of Typed Logic Programs Abstract Compilation for Sharing Analysis

Functional and Logic Programming: 5th International Symposium, FLOPS 2001 Tokyo, Japan, March 7–9, 2001 Proceedings Author: Herbert Kuchen, Kazunori Ueda Published by Springer Berlin Heidelberg ISBN: 978-3-540-41739-2 DOI: 10.1007/3-540-44716-4 Table of Contents: The Metalanguage λprolog and Its Implementation A Scalable Architecture for Proof-Carrying Code Parameterized Logic Programs where Computing Meets Learning Proving Syntactic Properties of Exceptions in an Ordered Logical Framework A Higher-Order Colon Translation Compiling Lazy Functional Programs Based on the Spineless Tagless G-machine for the Java Virtual Machine A Higher-Order Logic Programming Language with Constraints Specifying and Debugging Security Protocols via Hereditary Harrop Formulas and λProlog ‐ A Case-study ‐ An Effective Bottom-Up Semantics for First-Order Linear Logic Programs A Framework for Goal-Directed Bottom-Up Evaluation of Functional Logic Programs Theoretical Foundations for the Declarative Debugging of Lazy Functional Logic Programs Adding Linear Constraints over Real Numbers to Curry A Complete Selection Function for Lazy Conditional Narrowing An Abstract Machine Based System for a Lazy Narrowing Calculus Incremental Learning of Functional Logic Programs A General Type Inference Framework for Hindley/Milner Style Systems Monadic Encapsulation with Stack of Regions Well-Typed Logic Programs Are not Wrong A Framework for Analysis of Typed Logic Programs Abstract Compilation for Sharing Analysis

Includes bibliographies

"Algernon: An Introduction to Programming Logic" is a 1987 educational game designed by Tom Bretl, programmed by Larry Bank, and distributed by Sunburst Communications. It requires a 64K Apple ][+ or later.

"Algernon: An Introduction to Programming Logic" is a 1987 educational game designed by Tom Bretl, programmed by Larry Bank, and distributed by Sunburst Communications. It requires a 64K Apple ][+ or later.

TU Dresden CMS LM Foundations of Logic Programming Exam 2022-2023

The Journal of Logic Programming 1988: Volume 5 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1988_5_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1988-03_5_1 .

The Journal of Logic Programming 1992: Volume 14 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1992-08_13_4 . Next issue: sim_journal-of-logic-and-algebraic-programming_1992_14_contents .

The Journal of Logic and Algebraic Programming 1996: Volume 29 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1996_29_index . Next issue: sim_journal-of-logic-and-algebraic-programming_october-december-1996_29_1-3 .

The Journal of Logic and Algebraic Programming 1998: Volume 34 , Issue Index. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1997-12_33_3 . Next issue: sim_journal-of-logic-and-algebraic-programming_1998_34_contents . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1999: Volume 38 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1999_38_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1999-01_38_1 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1999: Volume 38 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1999_38_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1999-01_38_1 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1999: Volume 38 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1999_38_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1999-01_38_1 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1999: Volume 38 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1999_38_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1999-01_38_1 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1999: Volume 38 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1999_38_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1999-01_38_1 . Note: This issue has no cover

The Journal of Logic Programming 1984: Volume 1 , Issue Index. Digitized from IA1652909-07 . Next issue: sim_journal-of-logic-and-algebraic-programming_1984_1_contents .

The Journal of Logic Programming 1987: Volume 4 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1987_4_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1987-03_4_1 .

The Journal of Logic Programming 1989: Volume 7 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1989-05_6_3 . Next issue: sim_journal-of-logic-and-algebraic-programming_1989_7_contents .

The Journal of Logic Programming 1992: Volume 13 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1992-04_12_4 . Next issue: sim_journal-of-logic-and-algebraic-programming_1992_13_contents .

The Journal of Logic Programming 1992: Volume 14 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1992_14_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1992-10_14_1-2 .

The Journal of Logic Programming 1994: Volume 18 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1994_18_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1994-01_18_1 .