Downloads & Free Reading Options - Results

Includes bibliographical references and index

Includes bibliographical references and index

Intuitionistic logic programming provides the notion of embedded implication in rule bodies, which can be used to reason about a current database modified by the antecedent. This can be applied to a system that translates SQL to Datalog to solve SQL WITH queries, for which relations are locally defined and can therefore be understood as added to the current database. In addition, assumptions in SQL queries as either adding or removing data can be modelled in this way as well, which is an interesting feature for decision-support scenarios. This work suggests a way to apply intuitionistic logic programming to SQL, and provides a pointer to a working system implementing this idea.

Intuitionistic logic programming provides the notion of embedded implication in rule bodies, which can be used to reason about a current database modified by the antecedent. This can be applied to a system that translates SQL to Datalog to solve SQL WITH queries, for which relations are locally defined and can therefore be understood as added to the current database. In addition, assumptions in SQL queries as either adding or removing data can be modelled in this way as well, which is an interesting feature for decision-support scenarios. This work suggests a way to apply intuitionistic logic programming to SQL, and provides a pointer to a working system implementing this idea.

Tabling has been used for some time to improve efficiency of Prolog programs by memorizing answered queries. The same idea can be naturally used to memorize visited states during search for planning. In this paper we present a planner developed in the Picat language to solve the Petrobras planning problem. Picat is a novel Prolog-like language that provides pattern matching, deterministic and non-deterministic rules, and tabling as its core modelling and solving features. We demonstrate these capabilities using the Petrobras problem, where the goal is to plan transport of cargo items from ports to platforms using vessels with limited capacity. Monte Carlo Tree Search has been so far the best technique to tackle this problem and we will show that by using tabling we can achieve much better runtime efficiency and better plan quality.

In recent work, semantic games of independence-friendly logic were studied in strategic form in terms of (mixed strategy) Nash equilibria. The class of strategic games of independence-friendly logic is contained in the class of win-loss, zero-sum two-player games. In this note we draw on the theory of linear programming to develop tools to analyze the value of such games. We give two applications of these tools to independence-friendly logic under the so-called equilibrium semantics.

Logic programming has traditionally lacked devices for expressing mutually exclusive modules. We address this limitation by adopting choice-conjunctive modules of the form $D_0 \& D_1$ where $D_0, D_1$ are a conjunction of Horn clauses and $\&$ is a linear logic connective. Solving a goal $G$ using $D_0 \& D_1$ -- $exec(D_0 \& D_1,G)$ -- has the following operational semantics: $choose$ a successful one between $exec(D_0,G)$ and $exec(D_1,G)$. In other words, if $D_0$ is chosen in the course of solving $G$, then $D_1$ will be discarded and vice versa. Hence, the class of choice-conjunctive modules can capture the notion of mutually exclusive modules.

The purpose of this dissertation is to provide constructive proof that the logic programming language Prolog can be implemented an order of magnitude more efficiently than the best previous systems, so that its speed approaches imperative languages such as C for a significant class of problems. The driving force in the design is to encode each occurrence of a general feature of Prolog as simply as possible. The resulting system, Aquarius Prolog, is about five times faster than Quintus Prolog, a high performance commercial system, on a set of representative programs. The design is based on the following ideas: (1) Reduce instruction granularity. Use an execution model, the Berkeley Abstract Machine (BAM), that retains the good features of the Warren Abstract Machine (WAM), a standard execution model for Prolog, but is more easily optimized and closer to a real machine. (2) Exploit determinism. Compile deterministic programs with efficient conditional branches. Most predicates written by human programmers are deterministic, yet previous systems often compile them in an inefficient manner by simulating conditional branching with backtracking. (3) Specialize unification. Compile unification to the simplest possible code. Unification is a general pattern-matching operation that can do many things in the implementation: pass parameters, assign values to variables, allocate memory, and do conditional branching. (4) Dataflow analysis. Derive type information by global dataflow analysis to support these ideas. Because of limitations of the dataflow analysis, the system is not yet competitive with the C language for all programs. I outline the work that is needed to close the remaining gap.

The purpose of this dissertation is to provide constructive proof that the logic programming language Prolog can be implemented an order of magnitude more efficiently than the best previous systems, so that its speed approaches imperative languages such as C for a significant class of problems. The driving force in the design is to encode each occurrence of a general feature of Prolog as simply as possible. The resulting system, Aquarius Prolog, is about five times faster than Quintus Prolog, a high performance commercial system, on a set of representative programs. The design is based on the following ideas: (1) Reduce instruction granularity. Use an execution model, the Berkeley Abstract Machine (BAM), that retains the good features of the Warren Abstract Machine (WAM), a standard execution model for Prolog, but is more easily optimized and closer to a real machine. (2) Exploit determinism. Compile deterministic programs with efficient conditional branches. Most predicates written by human programmers are deterministic, yet previous systems often compile them in an inefficient manner by simulating conditional branching with backtracking. (3) Specialize unification. Compile unification to the simplest possible code. Unification is a general pattern-matching operation that can do many things in the implementation: pass parameters, assign values to variables, allocate memory, and do conditional branching. (4) Dataflow analysis. Derive type information by global dataflow analysis to support these ideas. Because of limitations of the dataflow analysis, the system is not yet competitive with the C language for all programs. I outline the work that is needed to close the remaining gap.

The purpose of this dissertation is to provide constructive proof that the logic programming language Prolog can be implemented an order of magnitude more efficiently than the best previous systems, so that its speed approaches imperative languages such as C for a significant class of problems. The driving force in the design is to encode each occurrence of a general feature of Prolog as simply as possible. The resulting system, Aquarius Prolog, is about five times faster than Quintus Prolog, a high performance commercial system, on a set of representative programs. The design is based on the following ideas: (1) Reduce instruction granularity. Use an execution model, the Berkeley Abstract Machine (BAM), that retains the good features of the Warren Abstract Machine (WAM), a standard execution model for Prolog, but is more easily optimized and closer to a real machine. (2) Exploit determinism. Compile deterministic programs with efficient conditional branches. Most predicates written by human programmers are deterministic, yet previous systems often compile them in an inefficient manner by simulating conditional branching with backtracking. (3) Specialize unification. Compile unification to the simplest possible code. Unification is a general pattern-matching operation that can do many things in the implementation: pass parameters, assign values to variables, allocate memory, and do conditional branching. (4) Dataflow analysis. Derive type information by global dataflow analysis to support these ideas. Because of limitations of the dataflow analysis, the system is not yet competitive with the C language for all programs. I outline the work that is needed to close the remaining gap.

The purpose of this dissertation is to provide constructive proof that the logic programming language Prolog can be implemented an order of magnitude more efficiently than the best previous systems, so that its speed approaches imperative languages such as C for a significant class of problems. The driving force in the design is to encode each occurrence of a general feature of Prolog as simply as possible. The resulting system, Aquarius Prolog, is about five times faster than Quintus Prolog, a high performance commercial system, on a set of representative programs. The design is based on the following ideas: (1) Reduce instruction granularity. Use an execution model, the Berkeley Abstract Machine (BAM), that retains the good features of the Warren Abstract Machine (WAM), a standard execution model for Prolog, but is more easily optimized and closer to a real machine. (2) Exploit determinism. Compile deterministic programs with efficient conditional branches. Most predicates written by human programmers are deterministic, yet previous systems often compile them in an inefficient manner by simulating conditional branching with backtracking. (3) Specialize unification. Compile unification to the simplest possible code. Unification is a general pattern-matching operation that can do many things in the implementation: pass parameters, assign values to variables, allocate memory, and do conditional branching. (4) Dataflow analysis. Derive type information by global dataflow analysis to support these ideas. Because of limitations of the dataflow analysis, the system is not yet competitive with the C language for all programs. I outline the work that is needed to close the remaining gap.

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.

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.

This progress report summarizes work performed under AFOSR-88-0152 on parallel logic programming, problem solving, and deductive databases. A parallel problem solving system, PRISM (Parallel Inference System), that was implemented on McMOB was ported to the BBN Butterfly machine. Two versions of PRISM were developed and are operational on the Butterfly: a message passing ring structure system and a shared-memory system. Experimental testing of PRISM on McMOB continued, while experiments were also conducted on the Butterfly systems. Three enhancements were made and completed during the grant period. These are: a capability to handle negated queries and a capability to assert and retract statements. In addition to the above, work continued in the area of informative answers to queries in deductive data bases. A thesis was completed on the subject. An interpreter was developed and is running, that can take restricted natural language as input and can respond with a cooperative natural language output. In the area of parallel software development, the following were accomplished. Theoretical work on slicing/splicing was completed. Tools were provided for software development using artificial intelligence techniques. AI software for massively parallel architectures was started.

This progress report summarizes work performed under AFOSR-88-0152 on parallel logic programming, problem solving, and deductive databases. A parallel problem solving system, PRISM (Parallel Inference System), that was implemented on McMOB was ported to the BBN Butterfly machine. Two versions of PRISM were developed and are operational on the Butterfly: a message passing ring structure system and a shared-memory system. Experimental testing of PRISM on McMOB continued, while experiments were also conducted on the Butterfly systems. Three enhancements were made and completed during the grant period. These are: a capability to handle negated queries and a capability to assert and retract statements. In addition to the above, work continued in the area of informative answers to queries in deductive data bases. A thesis was completed on the subject. An interpreter was developed and is running, that can take restricted natural language as input and can respond with a cooperative natural language output. In the area of parallel software development, the following were accomplished. Theoretical work on slicing/splicing was completed. Tools were provided for software development using artificial intelligence techniques. AI software for massively parallel architectures was started.

This progress report summarizes work performed under AFOSR-88-0152 on parallel logic programming, problem solving, and deductive databases. A parallel problem solving system, PRISM (Parallel Inference System), that was implemented on McMOB was ported to the BBN Butterfly machine. Two versions of PRISM were developed and are operational on the Butterfly: a message passing ring structure system and a shared-memory system. Experimental testing of PRISM on McMOB continued, while experiments were also conducted on the Butterfly systems. Three enhancements were made and completed during the grant period. These are: a capability to handle negated queries and a capability to assert and retract statements. In addition to the above, work continued in the area of informative answers to queries in deductive data bases. A thesis was completed on the subject. An interpreter was developed and is running, that can take restricted natural language as input and can respond with a cooperative natural language output. In the area of parallel software development, the following were accomplished. Theoretical work on slicing/splicing was completed. Tools were provided for software development using artificial intelligence techniques. AI software for massively parallel architectures was started.

This progress report summarizes work performed under AFOSR-88-0152 on parallel logic programming, problem solving, and deductive databases. A parallel problem solving system, PRISM (Parallel Inference System), that was implemented on McMOB was ported to the BBN Butterfly machine. Two versions of PRISM were developed and are operational on the Butterfly: a message passing ring structure system and a shared-memory system. Experimental testing of PRISM on McMOB continued, while experiments were also conducted on the Butterfly systems. Three enhancements were made and completed during the grant period. These are: a capability to handle negated queries and a capability to assert and retract statements. In addition to the above, work continued in the area of informative answers to queries in deductive data bases. A thesis was completed on the subject. An interpreter was developed and is running, that can take restricted natural language as input and can respond with a cooperative natural language output. In the area of parallel software development, the following were accomplished. Theoretical work on slicing/splicing was completed. Tools were provided for software development using artificial intelligence techniques. AI software for massively parallel architectures was started.

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 1998: Volume 36 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1998_36_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1998-07_36_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 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 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 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 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 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 is an active peer-reviewed academic journal featuring original research papers, survey and review articles, tutorial expositions and historical studies in logic programming. It was established in 1984 and is published 6 times a year by Elsevier. The journal provides a platform for researchers, scientists, and computer scientists to publish original research articles, reviews, and perspectives covering a wide range of topics related to the theoretical foundations and practical applications of logic-based programming and algebraic programming languages. It publishes research on programming methodologies, program verification, logic programming languages, type systems, and formal methods. The journal features articles that explore the use of logic and algebraic techniques for program analysis, synthesis, and optimization. It covers research on program semantics, constraint solving, program transformation, and software engineering techniques based on logical and algebraic principles. The Internet Archive Collection contains microfilm published between 1984 and 1999 The Journal of Logic and Algebraic Programming can be found online at: www.sciencedirect.com/journal/journal-of-logical-and-algebraic-methods-in-programming The ISSN is: 1567-8326 Publication History Journal of Logic Programming 0743-1066 (until vol.46, 2001) USA United States | The Journal of Logic and Algebraic Programming 1567-8326 Former titles (until 2014) NLD Netherlands

The Structure and Interpretation of Computer Programs

Tandy/Radio Shack Book: Z80 Programming for Logic Design (1978)(Osborne and Associates)

To help make logic programming more suitable for writing large systems, we develop linguistic mechanisms that permit the organization of logic programs around abstractions. In particular, we present the design of Denali, an equational logic programming language that supports predicate and data abstraction. The key issue in introducing predicate abstraction is dealing with the difference between the declarative and procedural interpretations of logic programs. We address this issue by introducing a two-dimensional type system to describe predicate interfaces. The two components are a sort system and a novel multi-valued mode system. Multi-valued modes constrain the ways in which arguments to predicates may be instantiated. A collection of such modes is defined by the programmer for each sort. The key issue in introducing data abstraction is providing ways to obtain equational unification procedures. We develop a pragmatic approach that relies upon the programmer to implement these procedures. We facilitate this by supporting a variety of techniques that simplify the problem. Among these techniques are treating unification on a sort-by-sort basis, layering implementations so as to exploit built-in unification procedures, and using the mode system to constrain the unification problem.

The initial version of PRISM uses a simulation of the ZMOB hardware, and has been fully tested and debugged. In addition, several enhancements were made to PRISM to permit experimental analyses to be made, and to incorporate additional features to take full advantage of parallelism in a problem solving environment. Tracing and a statistical gathering package were added to permit experimental analysis. An AND-parallelism capability was added to achieve a second version of the PRISM system, and other features were added to the system to more fully exploit parallelism. Preliminary application and evaluation studies were performed. In the area of systems hardware and software, the ZMOB processor is now fully functional and in everyday use with 128 processors. Work is continuing on an experimental upgrade of some of ZMOB's processors to 68000s. Basic system software for multiprocessing on ZMOB is becoming more robust and performance studies now pinpoint areas for improvement. Studies of parallel software debugging continue to prove the value of multiple program views, and in particular the dicing approach was verified in a controlled experiment. We have also constructed an interactive visual slicer. Studies of the automatic parallelization of programs continues. We can now slice/splice arbitrarily structured programs and have techniques that significantly reduce information overhead between the slices and the splicer. (Author)

The initial version of PRISM uses a simulation of the ZMOB hardware, and has been fully tested and debugged. In addition, several enhancements were made to PRISM to permit experimental analyses to be made, and to incorporate additional features to take full advantage of parallelism in a problem solving environment. Tracing and a statistical gathering package were added to permit experimental analysis. An AND-parallelism capability was added to achieve a second version of the PRISM system, and other features were added to the system to more fully exploit parallelism. Preliminary application and evaluation studies were performed. In the area of systems hardware and software, the ZMOB processor is now fully functional and in everyday use with 128 processors. Work is continuing on an experimental upgrade of some of ZMOB's processors to 68000s. Basic system software for multiprocessing on ZMOB is becoming more robust and performance studies now pinpoint areas for improvement. Studies of parallel software debugging continue to prove the value of multiple program views, and in particular the dicing approach was verified in a controlled experiment. We have also constructed an interactive visual slicer. Studies of the automatic parallelization of programs continues. We can now slice/splice arbitrarily structured programs and have techniques that significantly reduce information overhead between the slices and the splicer. (Author)

Ten papers were published and two additional papers were accepted for publication. Moreover, four (4) papers are currently under preparation, including joint papers with W. Drabent, H. Przymusinska, L. Pereira and D.S. Warren. Significant progress has been made towards both theoretical and algorithmic foundations of a non-monotonic reasoning system based on logic programming. An implementation of such a system, limited to circumscriptive theories, has been also completed.

The Journal of Logic Programming 1985: Volume 2 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1984-12_1_4 . Next issue: sim_journal-of-logic-and-algebraic-programming_1985_2_contents .

The Journal of Logic and Algebraic Programming 1997: Volume 33 , Issue Index. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1997-09_32_3 . Next issue: sim_journal-of-logic-and-algebraic-programming_1997_33_contents . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1998: Volume 37 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1998_37_index . Next issue: sim_journal-of-logic-and-algebraic-programming_october-december-1998_37_1-3 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1998: Volume 37 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1998_37_index . Next issue: sim_journal-of-logic-and-algebraic-programming_october-december-1998_37_1-3 . Note: This issue has no cover

Thesis advisor, Cheng-Tsu Wu

Thesis advisor, Cheng-Tsu Wu

Video content can be found here: https://www.youtube.com/channel/UC0BAd8tPlDqFvDYBemHcQPQ/

Video content can be found here: https://www.youtube.com/channel/UC0BAd8tPlDqFvDYBemHcQPQ/

Video content can be found here: https://www.youtube.com/channel/UC0BAd8tPlDqFvDYBemHcQPQ/

xviii, 184 pages ; 24 cm

The Journal of Logic Programming 1991: Volume 10 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_september-november-1990_9_2-3 . Next issue: sim_journal-of-logic-and-algebraic-programming_1991_10_contents .

This volume contains the papers presented at Arg-LPNMR 2016: First International Workshop on Argumentation in Logic Programming and Nonmonotonic Reasoning held on July 8-10, 2016 in New York City, NY.

A new approach for combining logic programming, rewriting, and lazy evaluation is described. It rests upon subsuming within logic programming, instead of upon extending it with, rewriting, and lazy evaluation. A non- terminating, non-deterministic rewrite rule system, F* and a reduction strategy for it, select, are refined. F* is shown to be reduction-complete in that select simplifies terms whenever possible. A class of F* programs called Deterministic F* is defined and shown to satisfy confluence, directedness, and minimality. Confluence ensures that every term can be simplified in at most one way. Directedness eliminates searching in simplification of terms. Minimality ensures that select simplifies terms in a minimum number of steps. Completeness and minimality enable select to exhibit, respectively, weak and strong forms of laziness. F* can be compiled into Horn clauses in such a way that when SLD- resolution interprets these, it directly simulates the behavior of select. Thus, SLD-resolution is make to exhibit laziness. LOG(F) is defined to be a logic programming system augmented with an F* compiler, and the equality axiom X=X. LOG(F) can be used to do lazy functional programming in logic, implement useful cases of the rule of substitution of equals for equals, and obtain a new proof of confluence for combinatory logic. (aw)

Includes bibliographical references and index

Includes bibliographical references and index

The Journal of Logic Programming 1990: Volume 9 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1990-05_8_3 . Next issue: sim_journal-of-logic-and-algebraic-programming_1990_9_contents .

From the bitsavers.org collection, a scanned-in computer-related document. test equipment :: hp :: 166x :: 01660-90902 1660-Series 100-MHz State 500-MHz Timing Logic Analyzers Programming Guide Aug92