Downloads & Free Reading Options - Results

xviii, 184 pages ; 24 cm

Includes index

Includes index

45 p. 28 cm

45 p. 28 cm

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)

my

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.

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.

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)

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)

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)

Available from National Technical Information Service, Springfield, Va

Includes index

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 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 Journal of Logic Programming 1989: Volume 7 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1989_7_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1989-07_7_1 .

The Journal of Logic Programming 1992: Volume 12 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1992_12_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1992-01_12_1-2 .

The Journal of Logic Programming 1992: Volume 12 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1992_12_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1992-01_12_1-2 .

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.

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.

CS 61A The Structure and Interpretation of Computer Programs Instructor Brian Harvey Spring 2008 Introduction to programming and computer science. This course exposes students to techniques of abstraction at several levels: (a) within a programming language, using higher-order functions, manifest types, data-directed programming, and message-passing; (b) between programming languages, using functional and rule-based languages as examples. It also relates these techniques to the practical problems of implementation of languages and algorithms on a von Neumann machine. There are several significant programming projects, programmed in a dialect of the LISP language.

The Journal of Logic Programming 1989: Volume 6 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1988-12_5_4 . Next issue: sim_journal-of-logic-and-algebraic-programming_1989_6_contents .

The Journal of Logic Programming 1994: Volume 18 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1993-11_17_2-4 . Next issue: sim_journal-of-logic-and-algebraic-programming_1994_18_contents .

The Journal of Logic Programming 1994: Volume 21 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_may-july-1994_19-20 . Next issue: sim_journal-of-logic-and-algebraic-programming_1994_21_contents .

The Journal of Logic Programming 1995: Volume 23 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1995-03_22_3 . Next issue: sim_journal-of-logic-and-algebraic-programming_1995_23_contents .

The Journal of Logic and Algebraic Programming 1999: Volume 40 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1999_40_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1999-07_40_1 . Note: This issue has no cover

The Structure and Interpretation of Computer Programs

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)"

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)"

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.

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.

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.

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.