Downloads & Free Reading Options - Results

Artificial intelligence (AI) ideas and techniques are critical to the development of intelligent information systems that will be used to collect, manipulate, and retrieve the vast amounts of space data produced by 'Missions to Planet Earth.' Natural language processing, inference, and expert systems are at the core of this space application of AI. This paper presents logic programming as an AI tool that can support inference (the ability to draw conclusions from a set of complicated and interrelated facts). It reports on the use of logic programming in the study of metadata specifications for a small problem domain of airborne sensors, and the dataset characteristics and pointers that are needed for data access.

The Journal of Logic Programming 1992: Volume 13 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1992_13_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1992-05_13_1 .

The Journal of Logic and Algebraic Programming 1999: Volume 39 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1999_39_index . Next issue: sim_journal-of-logic-and-algebraic-programming_april-june-1999_39_1-3 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1999: Volume 39 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1999_39_index . Next issue: sim_journal-of-logic-and-algebraic-programming_april-june-1999_39_1-3 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1999: Volume 39 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1999_39_index . Next issue: sim_journal-of-logic-and-algebraic-programming_april-june-1999_39_1-3 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1999: Volume 39 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1999_39_index . Next issue: sim_journal-of-logic-and-algebraic-programming_april-june-1999_39_1-3 . Note: This issue has no cover

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.

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 paradigm of Tabled Logic Programming (TLP) is now supported by a number of Prolog systems, including XSB, YAP Prolog, B-Prolog, Mercury, ALS, and Ciao. The reasons for this are partly theoretical: tabling ensures termination and optimal known complexity for queries to a large class of programs. However the overriding reasons are practical. TLP allows sophisticated programs to be written concisely and efficiently, especially when mechanisms such as tabled negation and call and answer subsumption are supported. As a result TLP has now been used in a variety of applications from program analysis to querying over the semantic web. This paper provides a survey of TLP and its applications as implemented in XSB Prolog, along with discussion of how XSB supports tabling with dynamically changing code, and in a multi-threaded environment.

The paradigm of Tabled Logic Programming (TLP) is now supported by a number of Prolog systems, including XSB, YAP Prolog, B-Prolog, Mercury, ALS, and Ciao. The reasons for this are partly theoretical: tabling ensures termination and optimal known complexity for queries to a large class of programs. However the overriding reasons are practical. TLP allows sophisticated programs to be written concisely and efficiently, especially when mechanisms such as tabled negation and call and answer subsumption are supported. As a result TLP has now been used in a variety of applications from program analysis to querying over the semantic web. This paper provides a survey of TLP and its applications as implemented in XSB Prolog, along with discussion of how XSB supports tabling with dynamically changing code, and in a multi-threaded environment.

The paradigm of Tabled Logic Programming (TLP) is now supported by a number of Prolog systems, including XSB, YAP Prolog, B-Prolog, Mercury, ALS, and Ciao. The reasons for this are partly theoretical: tabling ensures termination and optimal known complexity for queries to a large class of programs. However the overriding reasons are practical. TLP allows sophisticated programs to be written concisely and efficiently, especially when mechanisms such as tabled negation and call and answer subsumption are supported. As a result TLP has now been used in a variety of applications from program analysis to querying over the semantic web. This paper provides a survey of TLP and its applications as implemented in XSB Prolog, along with discussion of how XSB supports tabling with dynamically changing code, and in a multi-threaded environment.

The paradigm of Tabled Logic Programming (TLP) is now supported by a number of Prolog systems, including XSB, YAP Prolog, B-Prolog, Mercury, ALS, and Ciao. The reasons for this are partly theoretical: tabling ensures termination and optimal known complexity for queries to a large class of programs. However the overriding reasons are practical. TLP allows sophisticated programs to be written concisely and efficiently, especially when mechanisms such as tabled negation and call and answer subsumption are supported. As a result TLP has now been used in a variety of applications from program analysis to querying over the semantic web. This paper provides a survey of TLP and its applications as implemented in XSB Prolog, along with discussion of how XSB supports tabling with dynamically changing code, and in a multi-threaded environment.

The programming user guide for the Quantum Q-Logic 3

Since the seminal work of J. A. Robinson on resolution, many lifting lemmas for simplifying proofs of completeness of resolution have been proposed in the literature. In the logic programming framework, they may also help to detect some infinite derivations while proving goals under the SLD-resolution. In this paper, we first generalize a version of the lifting lemma, by extending the relation "is more general than" so that it takes into account only some arguments of the atoms. The other arguments, which we call neutral arguments, are disregarded. Then we propose two syntactic conditions of increasing power for identifying neutral arguments from mere inspection of the text of a logic program.

Defeasible reasoning is a simple but efficient approach to nonmonotonic reasoning that has recently attracted considerable interest and that has found various applications. Defeasible logic and its variants are an important family of defeasible reasoning methods. So far no relationship has been established between defeasible logic and mainstream nonmonotonic reasoning approaches. In this paper we establish close links to known semantics of logic programs. In particular, we give a translation of a defeasible theory D into a meta-program P(D). We show that under a condition of decisiveness, the defeasible consequences of D correspond exactly to the sceptical conclusions of P(D) under the stable model semantics. Without decisiveness, the result holds only in one direction (all defeasible consequences of D are included in all stable models of P(D)). If we wish a complete embedding for the general case, we need to use the Kunen semantics of P(D), instead.

Defeasible reasoning is a simple but efficient approach to nonmonotonic reasoning that has recently attracted considerable interest and that has found various applications. Defeasible logic and its variants are an important family of defeasible reasoning methods. So far no relationship has been established between defeasible logic and mainstream nonmonotonic reasoning approaches. In this paper we establish close links to known semantics of logic programs. In particular, we give a translation of a defeasible theory D into a meta-program P(D). We show that under a condition of decisiveness, the defeasible consequences of D correspond exactly to the sceptical conclusions of P(D) under the stable model semantics. Without decisiveness, the result holds only in one direction (all defeasible consequences of D are included in all stable models of P(D)). If we wish a complete embedding for the general case, we need to use the Kunen semantics of P(D), instead.

Defeasible reasoning is a simple but efficient approach to nonmonotonic reasoning that has recently attracted considerable interest and that has found various applications. Defeasible logic and its variants are an important family of defeasible reasoning methods. So far no relationship has been established between defeasible logic and mainstream nonmonotonic reasoning approaches. In this paper we establish close links to known semantics of logic programs. In particular, we give a translation of a defeasible theory D into a meta-program P(D). We show that under a condition of decisiveness, the defeasible consequences of D correspond exactly to the sceptical conclusions of P(D) under the stable model semantics. Without decisiveness, the result holds only in one direction (all defeasible consequences of D are included in all stable models of P(D)). If we wish a complete embedding for the general case, we need to use the Kunen semantics of P(D), instead.

The Journal of Logic and Algebraic Programming 1999: Volume 41 , Issue Index. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_august-september-1999_40_2-3 . Next issue: sim_journal-of-logic-and-algebraic-programming_1999_41_contents . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1999: Volume 41 , Issue Index. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_august-september-1999_40_2-3 . Next issue: sim_journal-of-logic-and-algebraic-programming_1999_41_contents . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1999: Volume 41 , Issue Index. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_august-september-1999_40_2-3 . Next issue: sim_journal-of-logic-and-algebraic-programming_1999_41_contents . Note: This issue has no cover

The Journal of Logic Programming 1993: Volume 16 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1993_16_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1993-05_16_1-2 .

Logic Programming can be broadly defined as "using logic to infer computational steps from existing propositions" However, mathematical logic cannot always infer computational steps because computational systems make use of arbitration for determining which message is processed next by a recipient that is sent multiple messages concurrently. Since arrival orders are in general indeterminate, they cannot be inferred from prior information by mathematical logic alone. Therefore mathematical logic cannot in general implement computation. Consequently, Procedural Embedding of Knowledge is strictly more general than Logic Programming. This conclusion is contrary to Robert Kowalski who stated "Looking back on our early discoveries, I value most the discovery that computation could be subsumed by deduction." Nevertheless, logic programming (like functional programming) can be a useful programming idiom. Over the course of history, the term "functional programming" has grown more precise and technical as the field has matured. Logic Programming should be on a similar trajectory. Accordingly, "Logic Programming" should have a general precise characterization. Kowalski's approach has been to advocate limiting Logic Programming to backward-chaining only inference based on resolution using reduction to conjunctive normal form in a global states model. In contrast, our approach is explore Logic Programming building on the logical inference of computational steps using inconsistency-robust reasoning in a configurations model. Because contemporary large software systems are pervasively inconsistent, it is not safe to reason about them using classical logic, e.g., using resolution theorem proving.

Tri 2 – 2015/2016

Tri 2 – 2015/2016

We show how categorial deduction can be implemented in higher-order (linear) logic programming, thereby realising parsing as deduction for the associative and non-associative Lambek calculi. This provides a method of solution to the parsing problem of Lambek categorial grammar applicable to a variety of its extensions.

The field of Distributed Constraint Optimization Problems (DCOPs) has gained momentum, thanks to its suitability in capturing complex problems (e.g., multi-agent coordination and resource allocation problems) that are naturally distributed and cannot be realistically addressed in a centralized manner. The state of the art in solving DCOPs relies on the use of ad-hoc infrastructures and ad-hoc constraint solving procedures. This paper investigates an infrastructure for solving DCOPs that is completely built on logic programming technologies. In particular, the paper explores the use of a general constraint solver (a constraint logic programming system in this context) to handle the agent-level constraint solving. The preliminary experiments show that logic programming provides benefits over a state-of-the-art DCOP system, in terms of performance and scalability, opening the doors to the use of more advanced technology (e.g., search strategies and complex constraints) for solving DCOPs.

The Journal of Logic Programming 1989: Volume 6 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1989_6_index . Next issue: sim_journal-of-logic-and-algebraic-programming_january-march-1989_6_1-2 .

The authors propose new variation of relative set abstraction as an extension to a lambdacalculus based functional language. This feature interacts orthogonally with the standard functional language capabilities, yet provides the full expressive power of first-order Horn-logic programming, as well as a very useful subset of higher-order Horn-logic programming. This resulting language lends itself to efficient interpretation, in that complete operational procedures are possible without computationally expensive primitives such as higher-order unification, unification relative to an equational theory, or general theorem-proving.

In everyday life it happens that a person has to reason about what other people think and how they behave, in order to achieve his goals. In other words, an individual may be required to adapt his behaviour by reasoning about the others' mental state. In this paper we focus on a knowledge representation language derived from logic programming which both supports the representation of mental states of individual communities and provides each with the capability of reasoning about others' mental states and acting accordingly. The proposed semantics is shown to be translatable into stable model semantics of logic programs with aggregates.

In this thesis, we present two approaches to a rigorous mathematical and algorithmic foundation of quantitative and statistical inference in constraint-based natural language processing. The first approach, called quantitative constraint logic programming, is conceptualized in a clear logical framework, and presents a sound and complete system of quantitative inference for definite clauses annotated with subjective weights. This approach combines a rigorous formal semantics for quantitative inference based on subjective weights with efficient weight-based pruning for constraint-based systems. The second approach, called probabilistic constraint logic programming, introduces a log-linear probability distribution on the proof trees of a constraint logic program and an algorithm for statistical inference of the parameters and properties of such probability models from incomplete, i.e., unparsed data. The possibility of defining arbitrary properties of proof trees as properties of the log-linear probability model and efficiently estimating appropriate parameter values for them permits the probabilistic modeling of arbitrary context-dependencies in constraint logic programs. The usefulness of these ideas is evaluated empirically in a small-scale experiment on finding the correct parses of a constraint-based grammar. In addition, we address the problem of computational intractability of the calculation of expectations in the inference task and present various techniques to approximately solve this task. Moreover, we present an approximate heuristic technique for searching for the most probable analysis in probabilistic constraint logic programs.

(We apologize for pidgin LaTeX) Schlipf \cite{sch91} proved that Stable Logic Programming (SLP) solves all $\mathit{NP}$ decision problems. We extend Schlipf's result to prove that SLP solves all search problems in the class $\mathit{NP}$. Moreover, we do this in a uniform way as defined in \cite{mt99}. Specifically, we show that there is a single $\mathrm{DATALOG}^{\neg}$ program $P_{\mathit{Trg}}$ such that given any Turing machine $M$, any polynomial $p$ with non-negative integer coefficients and any input $\sigma$ of size $n$ over a fixed alphabet $\Sigma$, there is an extensional database $\mathit{edb}_{M,p,\sigma}$ such that there is a one-to-one correspondence between the stable models of $\mathit{edb}_{M,p,\sigma} \cup P_{\mathit{Trg}}$ and the accepting computations of the machine $M$ that reach the final state in at most $p(n)$ steps. Moreover, $\mathit{edb}_{M,p,\sigma}$ can be computed in polynomial time from $p$, $\sigma$ and the description of $M$ and the decoding of such accepting computations from its corresponding stable model of $\mathit{edb}_{M,p,\sigma} \cup P_{\mathit{Trg}}$ can be computed in linear time. A similar statement holds for Default Logic with respect to $\Sigma_2^\mathrm{P}$-search problems\footnote{The proof of this result involves additional technical complications and will be a subject of another publication.}.

We present the CIFF proof procedure for abductive logic programming with constraints, and we prove its correctness. CIFF is an extension of the IFF proof procedure for abductive logic programming, relaxing the original restrictions over variable quantification (allowedness conditions) and incorporating a constraint solver to deal with numerical constraints as in constraint logic programming. Finally, we describe the CIFF system, comparing it with state of the art abductive systems and answer set solvers and showing how to use it to program some applications. (To appear in Theory and Practice of Logic Programming - TPLP).

We introduce a lazy approach to the explanation-based approximation of probabilistic logic programs. It uses only the most significant part of the program when searching for explanations. The result is a fast and anytime approximate inference algorithm which returns hard lower and upper bounds on the exact probability. We experimentally show that this method outperforms state-of-the-art approximate inference.

The Journal of Logic and Algebraic Programming 1997: Volume 32 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1997_32_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1997-07_32_1 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1997: Volume 32 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1997_32_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1997-07_32_1 . Note: This issue has no cover

The Journal of Logic Programming 1995: Volume 23 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1995_23_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1995-04_23_1 .

The major focus of this year's effort has been on the development of a formal mathematical basis for logic programming. This report highlights four primary areas of on-going investigation into this research: 1) stratified knowledge bases, 2) the equivalence of non-classical logic programs, 3) multi- valued logic and logic programming, and 4) the topological aspects of logic programs. In addition, the MetaProlog (an extension of Prolog 1) and meta-logic programming are discussed. (aw)

Argumentation has proved a useful tool in defining formal semantics for assumption-based reasoning by viewing a proof as a process in which proponents and opponents attack each others arguments by undercuts (attack to an argument's premise) and rebuts (attack to an argument's conclusion). In this paper, we formulate a variety of notions of attack for extended logic programs from combinations of undercuts and rebuts and define a general hierarchy of argumentation semantics parameterised by the notions of attack chosen by proponent and opponent. We prove the equivalence and subset relationships between the semantics and examine some essential properties concerning consistency and the coherence principle, which relates default negation and explicit negation. Most significantly, we place existing semantics put forward in the literature in our hierarchy and identify a particular argumentation semantics for which we prove equivalence to the paraconsistent well-founded semantics with explicit negation, WFSX$_p$. Finally, we present a general proof theory, based on dialogue trees, and show that it is sound and complete with respect to the argumentation semantics.

Argumentation has proved a useful tool in defining formal semantics for assumption-based reasoning by viewing a proof as a process in which proponents and opponents attack each others arguments by undercuts (attack to an argument's premise) and rebuts (attack to an argument's conclusion). In this paper, we formulate a variety of notions of attack for extended logic programs from combinations of undercuts and rebuts and define a general hierarchy of argumentation semantics parameterised by the notions of attack chosen by proponent and opponent. We prove the equivalence and subset relationships between the semantics and examine some essential properties concerning consistency and the coherence principle, which relates default negation and explicit negation. Most significantly, we place existing semantics put forward in the literature in our hierarchy and identify a particular argumentation semantics for which we prove equivalence to the paraconsistent well-founded semantics with explicit negation, WFSX$_p$. Finally, we present a general proof theory, based on dialogue trees, and show that it is sound and complete with respect to the argumentation semantics.

Язык программирования Форт (англ. forth вперед и одновременное сокращение от fourth четвертый), который лежит в основе языка ForthLogicTM, появился в начале 1970-х гг. в США. Его изобретатель Чарльз Мур сначала применил его для разработки программного обеспечения микро-ЭВМ, которая управляла работой радиотелескопа. Преимущества работы с языком Форт б

6800 Programming for Logic Design By Adam Osborne Copyright 1977 This description contains and overview of the book, a list of the table of contents and a review of the book by Jeff Grossman from The Best of Creative Computing, Volume 3. Introduction This book explains how an assembly language program within a microcomputer system can replace combinational logic- that is, the combined use of "off-the-shelf," non-programmable logic devices, such as standard 7400 series digital logic. If you are a logic designer, this book will teach you how to do your old job in a new way- by creating assembly language programs within a microcomputer system. If you are a programmer, this book will show you how programming has found a new purpose- in logic design. This is a "how to do it" book; as such, it has to become very specific, so a particular type of microcomputer, the MC6800, is referenced directly. Companies manufacturing these microcomputers are: Motorola. Incorporated Semiconductor Products Division 3501 Ed Bluestein Boulevard Austin, Texas 78721 American Microsystems 3800 Homestead Road Santa Clara, California 95051 What This Book Assumes You Know This book is a sequel to An Introduction To Microcomputers , which was a single volume in its first edition, but is two volumes in its second edition. An Introduction To Microcomputers describes microprocessors and microcomputers conceptually; it does not address itself to the practical matter of implementing a concept. This book addresses the practical matter of implementation. In that this book is a sequel, it makes a single assumption- that you have read, or you otherwise understand the material covered in An Introduction To Microcomputers. However, before launching into a real design project, you will need vendor literature that specifically describes the devices you have elected to use. Note in particular that hardware and timing are not described in this book, either for the MC6800 CPU, or any other microcomputer devices; sufficient information may be found in An Introduction To Microcomputers, Volume II- Some Real Products. The MC6800 instruction set is described in Chapter 6 of this book, since programming is what this book is all about. Understanding Assembly Language Assembly language instructions are the transfer functions of a microcomputer system; taken together, they constitute an "instruction set," which describes the individual operations which the microcomputer can perform. You define the events which must occur within the microcomputer system serially- as a sequence of instructions, which, taken together, constitute an assembly language program. In reality, understanding what individual instructions do within a microcomputer system is very straightforward; it is one of the simplest aspects of working with microcomputers. Yet it unduly terrifies users who are new to programming. If that includes you, a word of advice - forget about mnemonics and instruction sets; take instructions one at a time as you encounter them in this book. When you do not understand what an instruction is doing, look it up in Chapter 6. The specter of "programming" will haunt you only if you let it. How This Book Has Been Printed Notice that text in this book has been printed in boldface type and lightface type. This has been done to help you skip those parts of the book that cover subject matter with which you are familiar. You can be sure that lightface type only expands on information presented in the previous boldface type. Therefore, only read boldface type until you reach a subject about which you want to know more, at which point start reading the lightface type. Table of Contents 1) Introduction 2) Assembly Language and Digital Logic 3) A Direct Digital Logic Simulation 4) A Simple Program 5) A Programmer's Perspective 6) The MC6800 Instruction Set 7) Some Commonly Used Routines Review of 6800 Programming for Logic Design by Adam Osborne Review by Jeff Grossman This review was published in the 1980 book, The Best of Creative Computing, Volume 3 on page 305.   6800 Programming for Logic Design. Adam Osborne. Adam Osborne and Associates, Inc. 289 pp., paperback. $7.50, 1977. With all the largely worthless books being published about microprocessors and microcomputers, it is refreshing to find one that sets its goals short of solving all the world's problems, and then meets these goals with a clarity, conciseness, and competence not often found in other books on the same subject. Author Osborne's intent is to show how assembly-language programs, in microprocessors, can replace discrete logic components. This is explained in the context of the Motorola 6800, but is applicable to almost any microprocessor. In seven chapters, the last two of which are 6800 reference material, the reader is guided from software simulation of gates to digital-system implementation via programming. Osborne begins by showing how simple gates and flip-flops can be replaced by small segments of assembly-language code.  He then points out that using a microprocessor to replace a gate or a flip-flop is wasteful, and presents an example of replacing an entire circuit with a microprocessor.  The circuit, used throughout the book, is an excellent vehicle for getting concepts across.  The circuit is taken from an actual product, the Qume daisy-wheel printer, and provides a mixture of synchronization, timing delay, and control problems that manages to illustrate most of the major issues in this type of design.  Again the reader is told that all is not perfect.  The assembly-language program, while functionally correct, is really a direct gate and flip-flop emulation of the print-wheel and hammer-control circuit.  This is generally not the best approach as such a direct simulation of a working digital circuit may not work due to unsuspected timing dependencies, lack of parallelism, etc.  The circuit is then re-implemented, ignoring the gates and, instead of concentrating on providing the functionality of the original circuit and preserving its input/output relationship.  But the author is not finished yet.  He describes a third, and final, program with some optimizations revealed by examining the problem from a software viewpoint. A unique feature of this book is that it is printed in boldface and lightface type.  The boldface type (more sparse) presents the key ideas, while the lightface type expands upon them.  Thus the reader can skip the detailed explanations when not required, but, upon reaching an unfamiliar topic, will find sufficient detail to answer most questions.  The only criticism is that the diagrams tend to be somewhat cluttered.  Particularly annoying is the practice of drawing arrows directly on assembly-language and diagram text to illustrate a point.  This, however, is a minor problem in an otherwise fine book. The author assumes a knowledge of basic microprocessor principles.  In practice, someone with a background in elementary combinational and sequential circuits and some form of programming will be able to benefit from this book.  6800 Programming for Logic Design is not for those who get their thrills by playing Spacewar, but anyone who designs microprocessor systems, or who is interested in doing so, will find this book interesting, informative, and useful. Jeff Grossman Cambridge,MA

Includes index

This paper proposed the question "How do we teach logical thinking and sophisticated mathematics to unsophisticated college students?" One answer among many is through the writing of computer programs. The writing of computer algorithms is mathematical problem solving and logic in disguise and it may attract students who would otherwise stop taking mathematics courses after their required sequence is finished. In college classrooms in the United States, there is often an over-involvement with the calculation aspect of mathematics, especially in today's technical environment. The emphasis should fall on the teachers' developing of logic in students. Just like mathematical algorithms, computer algorithms however simple, employ logical steps which will result in the desired conclusion. Mathematics teachers should take advantage of the inumerable opportunities, even in a beginner's computer programming course, to play with algorithms that may aid students in the development of logical ways to approach mathematical problems. (MA)

AiGerm (Artificially Intelligent Graphical Entity Relation Modeler) is a relational data base query and programming language front end for MCC (Mission Control Center)/STP's (Space Test Program) Germ (Graphical Entity Relational Modeling) system. It is intended as an add-on component of the Germ system to be used for navigating very large networks of information. It can also function as an expert system shell for prototyping knowledge-based systems. AiGerm provides an interface between the programming language and Germ.

Constructor-Based Conditional Rewriting Logic is a general framework for integrating first-order functional and logic programming which gives an algebraic semantics for non-deterministic functional-logic programs. In the context of this formalism, we introduce a simple notion of program module as an open program which can be extended together with several mechanisms to combine them. These mechanisms are based on a reduced set of operations. However, the high expressiveness of these operations enable us to model typical constructs for program modularization like hiding, export/import, genericity/instantiation, and inheritance in a simple way. We also deal with the semantic aspects of the proposal by introducing an immediate consequence operator, and studying several alternative semantics for a program module, based on this operator, in the line of logic programming: the operator itself, its least fixpoint (the least model of the module), the set of its pre-fixpoints (term models of the module), and some other variations in order to find a compositional and fully abstract semantics wrt the set of operations and a natural notion of observability.

We present a formulation of the problem of probabilistic model checking as one of query evaluation over probabilistic logic programs. To the best of our knowledge, our formulation is the first of its kind, and it covers a rich class of probabilistic models and probabilistic temporal logics. The inference algorithms of existing probabilistic logic-programming systems are well defined only for queries with a finite number of explanations. This restriction prohibits the encoding of probabilistic model checkers, where explanations correspond to executions of the system being model checked. To overcome this restriction, we propose a more general inference algorithm that uses finite generative structures (similar to automata) to represent families of explanations. The inference algorithm computes the probability of a possibly infinite set of explanations directly from the finite generative structure. We have implemented our inference algorithm in XSB Prolog, and use this implementation to encode probabilistic model checkers for a variety of temporal logics, including PCTL and GPL (which subsumes PCTL*). Our experiment results show that, despite the highly declarative nature of their encodings, the model checkers constructed in this manner are competitive with their native implementations.

Available from National Technical Information Service, Springfield, Va

Available from National Technical Information Service, Springfield, Va

Available from National Technical Information Service, Springfield, Va

Available from National Technical Information Service, Springfield, Va