Downloads & Free Reading Options - Results

x, 389 p. : 24 cm

x, 389 p. : 24 cm

The Journal of Logic Programming 1986: Volume 3 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1986_3_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1986-04_3_1 .

The Journal of Logic Programming 1990: Volume 8 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1990_8_index . Next issue: sim_journal-of-logic-and-algebraic-programming_january-march-1990_8_1-2 .

The Journal of Logic Programming 1990: Volume 8 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1990_8_index . Next issue: sim_journal-of-logic-and-algebraic-programming_january-march-1990_8_1-2 .

The Journal of Logic Programming 1990: Volume 8 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1990_8_index . Next issue: sim_journal-of-logic-and-algebraic-programming_january-march-1990_8_1-2 .

The Journal of Logic Programming 1990: Volume 8 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1990_8_index . Next issue: sim_journal-of-logic-and-algebraic-programming_january-march-1990_8_1-2 .

The Journal of Logic Programming 1990: Volume 8 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1990_8_index . Next issue: sim_journal-of-logic-and-algebraic-programming_january-march-1990_8_1-2 .

The Journal of Logic Programming 1990: Volume 8 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1990_8_index . Next issue: sim_journal-of-logic-and-algebraic-programming_january-march-1990_8_1-2 .

The Journal of Logic Programming 1995: Volume 22 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1995_22_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1995-01_22_1 .

The Journal of Logic Programming 1995: Volume 22 , Issue CONTENTS. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1995_22_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1995-01_22_1 .

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.

Developers are increasingly choosing datastores that sacrifice strong consistency guarantees in exchange for improved performance and availability. Unfortunately, writing reliable distributed programs without the benefit of strong consistency can be very challenging. In this talk, Recorded as BashoChats 004 in San Francisco, Neil Conway discusses work from his group at UC Berkeley that aims to make it easier to write distributed programs without relying on strong consistency. Bloom is a declarative programming language for distributed computing, while CALM is an analysis technique that identifies programs that are guaranteed to be eventually consistent. He then discussed his recent work on extending CALM to support a broader range of programs, drawing upon ideas from CRDTs. Source: https://vimeo.com/45111940 Uploader: Basho Technologies

Developers are increasingly choosing datastores that sacrifice strong consistency guarantees in exchange for improved performance and availability. Unfortunately, writing reliable distributed programs without the benefit of strong consistency can be very challenging. In this talk, Recorded as BashoChats 004 in San Francisco, Neil Conway discusses work from his group at UC Berkeley that aims to make it easier to write distributed programs without relying on strong consistency. Bloom is a declarative programming language for distributed computing, while CALM is an analysis technique that identifies programs that are guaranteed to be eventually consistent. He then discussed his recent work on extending CALM to support a broader range of programs, drawing upon ideas from CRDTs. Source: https://vimeo.com/45111940 Uploader: Basho Technologies

Developers are increasingly choosing datastores that sacrifice strong consistency guarantees in exchange for improved performance and availability. Unfortunately, writing reliable distributed programs without the benefit of strong consistency can be very challenging. In this talk, Recorded as BashoChats 004 in San Francisco, Neil Conway discusses work from his group at UC Berkeley that aims to make it easier to write distributed programs without relying on strong consistency. Bloom is a declarative programming language for distributed computing, while CALM is an analysis technique that identifies programs that are guaranteed to be eventually consistent. He then discussed his recent work on extending CALM to support a broader range of programs, drawing upon ideas from CRDTs. Source: https://vimeo.com/45111940 Uploader: Basho Technologies

Developers are increasingly choosing datastores that sacrifice strong consistency guarantees in exchange for improved performance and availability. Unfortunately, writing reliable distributed programs without the benefit of strong consistency can be very challenging. In this talk, Recorded as BashoChats 004 in San Francisco, Neil Conway discusses work from his group at UC Berkeley that aims to make it easier to write distributed programs without relying on strong consistency. Bloom is a declarative programming language for distributed computing, while CALM is an analysis technique that identifies programs that are guaranteed to be eventually consistent. He then discussed his recent work on extending CALM to support a broader range of programs, drawing upon ideas from CRDTs. Source: https://vimeo.com/45111940 Uploader: Basho Technologies

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.

With sound unification, Definite Clause Grammars and compact expression of combinatorial generation algorithms, logic programming is shown to conveniently host a declarative playground where interesting properties and behaviors emerge from the interaction of heterogenous but deeply connected computational objects. Compact combinatorial generation algorithms are given for several families of lambda terms, including open, closed, simply typed and linear terms as well as type inference and normal order reduction algorithms. We describe a Prolog-based combined lambda term generator and type-inferrer for closed well-typed terms of a given size, in de Bruijn notation. We introduce a compressed de Bruijn representation of lambda terms and define its bijections to standard representations. Our compressed terms facilitate derivation of size-proportionate ranking and unranking algorithms of lambda terms and their inferred simple types. The S and K combinator expressions form a well-known Turing-complete subset of the lambda calculus. We specify evaluation, type inference and combinatorial generation algorithms for SK-combinator trees. In the process, we unravel properties shedding new light on interesting aspects of their structure and distribution. A uniform representation, as binary trees with empty leaves, is given to expressions built with Rosser's X-combinator, natural numbers, lambda terms and simple types. Using this shared representation, ranking/unranking algorithm of lambda terms to tree-based natural numbers are described. Our algorithms, expressed as an incrementally developed literate Prolog program, implement a declarative playground for exploration of representations, encodings and computations with uniformly represented lambda terms, types, combinators and tree-based arithmetic.

The emphasis is made on the juxtaposition of (quantum~theorem) proving versus quantum (theorem~proving). The logical contents of verification of the statements concerning quantum systems is outlined. The Zittereingang (trembling input) principle is introduced to enhance the resolution of predicate satisfiability problem provided the processor is in a position to perform operations with continuous input. A realization of Zittereingang machine by a quantum system is suggested.

The emphasis is made on the juxtaposition of (quantum~theorem) proving versus quantum (theorem~proving). The logical contents of verification of the statements concerning quantum systems is outlined. The Zittereingang (trembling input) principle is introduced to enhance the resolution of predicate satisfiability problem provided the processor is in a position to perform operations with continuous input. A realization of Zittereingang machine by a quantum system is suggested.

Paisley is an extensible lightweight embedded domain-specific language for nondeterministic pattern matching in Java. Using simple APIs and programming idioms, it brings the power of functional-logic processing of arbitrary data objects to the Java platform, without constraining the underlying object-oriented semantics. Here we present an extension to the Paisley framework that adds pattern-based control flow. It exploits recent additions to the Java language, namely functional interfaces and lambda expressions, for an explicit and transparent continuation-passing style approach to control. We evaluate the practical impact of the novel features on a real-world case study that reengineers a third-party open-source project to use Paisley in place of conventional object-oriented data query idioms. We find the approach viable for incremental refactoring of legacy code, with significant qualitative improvements regarding separation of concerns, clarity and intentionality, thus making for easier code understanding, testing and debugging.

(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).

Xerox PARC  (Palo Alto Research Center) Parallel Logic Programming Ehud Shapiro Nov 25, 1986 Reel 1 of 2

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 .

Lifted inference has been proposed for various probabilistic logical frameworks in order to compute the probability of queries in a time that depends on the size of the domains of the random variables rather than the number of instances. Even if various authors have underlined its importance for probabilistic logic programming (PLP), lifted inference has been applied up to now only to relational languages outside of logic programming. In this paper we adapt Generalized Counting First Order Variable Elimination (GC-FOVE) to the problem of computing the probability of queries to probabilistic logic programs under the distribution semantics. In particular, we extend the Prolog Factor Language (PFL) to include two new types of factors that are needed for representing ProbLog programs. These factors take into account the existing causal independence relationships among random variables and are managed by the extension to variable elimination proposed by Zhang and Poole for dealing with convergent variables and heterogeneous factors. Two new operators are added to GC-FOVE for treating heterogeneous factors. The resulting algorithm, called LP$^2$ for Lifted Probabilistic Logic Programming, has been implemented by modifying the PFL implementation of GC-FOVE and tested on three benchmarks for lifted inference. A comparison with PITA and ProbLog2 shows the potential of the approach.

Lifted inference has been proposed for various probabilistic logical frameworks in order to compute the probability of queries in a time that depends on the size of the domains of the random variables rather than the number of instances. Even if various authors have underlined its importance for probabilistic logic programming (PLP), lifted inference has been applied up to now only to relational languages outside of logic programming. In this paper we adapt Generalized Counting First Order Variable Elimination (GC-FOVE) to the problem of computing the probability of queries to probabilistic logic programs under the distribution semantics. In particular, we extend the Prolog Factor Language (PFL) to include two new types of factors that are needed for representing ProbLog programs. These factors take into account the existing causal independence relationships among random variables and are managed by the extension to variable elimination proposed by Zhang and Poole for dealing with convergent variables and heterogeneous factors. Two new operators are added to GC-FOVE for treating heterogeneous factors. The resulting algorithm, called LP$^2$ for Lifted Probabilistic Logic Programming, has been implemented by modifying the PFL implementation of GC-FOVE and tested on three benchmarks for lifted inference. A comparison with PITA and ProbLog2 shows the potential of the approach.

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

How to extract negative information from programs is an important issue in logic programming. Here we address the problem for functional logic programs, from a proof-theoretic perspective. The starting point of our work is CRWL (Constructor based ReWriting Logic), a well established theoretical framework for functional logic programming, whose fundamental notion is that of non-strict non-deterministic function. We present a proof calculus, CRWLF, which is able to deduce negative information from CRWL-programs. In particular, CRWLF is able to prove finite failure of reduction within CRWL.

We analyze the problem of defining well-founded semantics for ordered logic programs within a general framework based on alternating fixpoint theory. We start by showing that generalizations of existing answer set approaches to preference are too weak in the setting of well-founded semantics. We then specify some informal yet intuitive criteria and propose a semantical framework for preference handling that is more suitable for defining well-founded semantics for ordered logic programs. The suitability of the new approach is convinced by the fact that many attractive properties are satisfied by our semantics. In particular, our semantics is still correct with respect to various existing answer sets semantics while it successfully overcomes the weakness of their generalization to well-founded semantics. Finally, we indicate how an existing preferred well-founded semantics can be captured within our semantical framework.

We analyze the problem of defining well-founded semantics for ordered logic programs within a general framework based on alternating fixpoint theory. We start by showing that generalizations of existing answer set approaches to preference are too weak in the setting of well-founded semantics. We then specify some informal yet intuitive criteria and propose a semantical framework for preference handling that is more suitable for defining well-founded semantics for ordered logic programs. The suitability of the new approach is convinced by the fact that many attractive properties are satisfied by our semantics. In particular, our semantics is still correct with respect to various existing answer sets semantics while it successfully overcomes the weakness of their generalization to well-founded semantics. Finally, we indicate how an existing preferred well-founded semantics can be captured within our semantical framework.

We analyze the problem of defining well-founded semantics for ordered logic programs within a general framework based on alternating fixpoint theory. We start by showing that generalizations of existing answer set approaches to preference are too weak in the setting of well-founded semantics. We then specify some informal yet intuitive criteria and propose a semantical framework for preference handling that is more suitable for defining well-founded semantics for ordered logic programs. The suitability of the new approach is convinced by the fact that many attractive properties are satisfied by our semantics. In particular, our semantics is still correct with respect to various existing answer sets semantics while it successfully overcomes the weakness of their generalization to well-founded semantics. Finally, we indicate how an existing preferred well-founded semantics can be captured within our semantical framework.

From the bitsavers.org collection, a scanned-in computer-related document. test equipment :: hp :: 165xx :: Preliminary Programming Information for HP 16500A Logic Analysis System Dec87

From the bitsavers.org collection, a scanned-in computer-related document. test equipment :: hp :: 165xx :: Preliminary Programming Information for HP 16500A Logic Analysis System Dec87

From the bitsavers.org collection, a scanned-in computer-related document. test equipment :: hp :: 165xx :: Preliminary Programming Information for HP 16500A Logic Analysis System Dec87

From the bitsavers.org collection, a scanned-in computer-related document. test equipment :: hp :: 165xx :: Preliminary Programming Information for HP 16500A Logic Analysis System Dec87

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

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

Different notions of equivalence, such as the prominent notions of strong and uniform equivalence, have been studied in Answer-Set Programming, mainly for the purpose of identifying programs that can serve as substitutes without altering the semantics, for instance in program optimization. Such semantic comparisons are usually characterized by various selections of models in the logic of Here-and-There (HT). For uniform equivalence however, correct characterizations in terms of HT-models can only be obtained for finite theories, respectively programs. In this article, we show that a selection of countermodels in HT captures uniform equivalence also for infinite theories. This result is turned into coherent characterizations of the different notions of equivalence by countermodels, as well as by a mixture of HT-models and countermodels (so-called equivalence interpretations). Moreover, we generalize the so-called notion of relativized hyperequivalence for programs to propositional theories, and apply the same methodology in order to obtain a semantic characterization which is amenable to infinite settings. This allows for a lifting of the results to first-order theories under a very general semantics given in terms of a quantified version of HT. We thus obtain a general framework for the study of various notions of equivalence for theories under answer-set semantics. Moreover, we prove an expedient property that allows for a simplified treatment of extended signatures, and provide further results for non-ground logic programs. In particular, uniform equivalence coincides under open and ordinary answer-set semantics, and for finite non-ground programs under these semantics, also the usual characterization of uniform equivalence in terms of maximal and total HT-models of the grounding is correct, even for infinite domains, when corresponding ground programs are infinite.

Inductive logic programming, or relational learning, is a powerful paradigm for machine learning or data mining. However, in order for ILP to become practically useful, the efficiency of ILP systems must improve substantially. To this end, the notion of a query pack is introduced: it structures sets of similar queries. Furthermore, a mechanism is described for executing such query packs. A complexity analysis shows that considerable efficiency improvements can be achieved through the use of this query pack execution mechanism. This claim is supported by empirical results obtained by incorporating support for query pack execution in two existing learning systems.

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 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 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.

We propose a framework grounded in Logic Programming for representing and reasoning about business processes from both the procedural and ontological point of views. In particular, our goal is threefold: (1) define a logical language and a formal semantics for process models enriched with ontology-based annotations; (2) provide an effective inference mechanism that supports the combination of reasoning services dealing with the structural definition of a process model, its behavior, and the domain knowledge related to the participating business entities; (3) implement such a theoretical framework into a process modeling and reasoning platform. To this end we define a process ontology coping with a relevant fragment of the popular BPMN modeling notation. The behavioral semantics of a process is defined as a state transition system by following an approach similar to the Fluent Calculus, and allows us to specify state change in terms of preconditions and effects of the enactment of activities. Then we show how the procedural process knowledge can be seamlessly integrated with the domain knowledge specified by using the OWL 2 RL rule-based ontology language. Our framework provides a wide range of reasoning services, including CTL model checking, which can be performed by using standard Logic Programming inference engines through a goal-oriented, efficient, sound and complete evaluation procedure. We also present a software environment implementing the proposed framework, and we report on an experimental evaluation of the system, whose results are encouraging and show the viability of the approach.

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.

We introduce a framework for supporting learning to program in the paradigm of Answer Set Programming (ASP), which is a declarative logic programming formalism. Based on the idea of teaching by asking the student to complete small example ASP programs, we introduce a three-stage method for giving hints to the student without revealing the correct solution of an example. We categorize mistakes into (i) syntactic mistakes, (ii) unexpected but syntactically correct input, and (iii) semantic mistakes, describe mathematical definitions of these mistakes, and show how to compute hints from these definitions.

This paper proposes an evaluation of the adequacy of the constraint logic programming paradigm for natural language processing. Theoretical aspects of this question have been discussed in several works. We adopt here a pragmatic point of view and our argumentation relies on concrete solutions. Using actual contraints (in the CLP sense) is neither easy nor direct. However, CLP can improve parsing techniques in several aspects such as concision, control, efficiency or direct representation of linguistic formalism. This discussion is illustrated by several examples and the presentation of an HPSG parser.

This paper addresses two central problems for probabilistic processing models: parameter estimation from incomplete data and efficient retrieval of most probable analyses. These questions have been answered satisfactorily only for probabilistic regular and context-free models. We address these problems for a more expressive probabilistic constraint logic programming model. We present a log-linear probability model for probabilistic constraint logic programming. On top of this model we define an algorithm to estimate the parameters and to select the properties of log-linear models from incomplete data. This algorithm is an extension of the improved iterative scaling algorithm of Della-Pietra, Della-Pietra, and Lafferty (1995). Our algorithm applies to log-linear models in general and is accompanied with suitable approximation methods when applied to large data spaces. Furthermore, we present an approach for searching for most probable analyses of the probabilistic constraint logic programming model. This method can be applied to the ambiguity resolution problem in natural language processing applications.

In this paper, we present our proposal to Constraint Functional Logic Programming over Finite Domains (CFLP(FD)) with a lazy functional logic programming language which seamlessly embodies finite domain (FD) constraints. This proposal increases the expressiveness and power of constraint logic programming over finite domains (CLP(FD)) by combining functional and relational notation, curried expressions, higher-order functions, patterns, partial applications, non-determinism, lazy evaluation, logical variables, types, domain variables, constraint composition, and finite domain constraints. We describe the syntax of the language, its type discipline, and its declarative and operational semantics. We also describe TOY(FD), an implementation for CFLPFD(FD), and a comparison of our approach with respect to CLP(FD) from a programming point of view, showing the new features we introduce. And, finally, we show a performance analysis which demonstrates that our implementation is competitive with respect to existing CLP(FD) systems and that clearly outperforms the closer approach to CFLP(FD).