Downloads & Free Reading Options - Results

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 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 and Algebraic Programming 1996: Volume 27 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1996_27_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1996-04_27_1 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1996: Volume 27 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1996_27_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1996-04_27_1 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1996: Volume 27 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1996_27_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1996-04_27_1 . Note: This issue has no cover

The Journal of Logic and Algebraic Programming 1996: Volume 27 , Issue CONTENTS. Digitized from IA1652909-05 . Previous issue: sim_journal-of-logic-and-algebraic-programming_1996_27_index . Next issue: sim_journal-of-logic-and-algebraic-programming_1996-04_27_1 . Note: This issue has no cover

The primary objective of this project is to develop a new model of natural human reasoning with imprecise linguistic information. Key to this model is a collection of abstraction mechanisms based on the concept of a linguistic variable, which was first introduced for this purpose within the context of a semantics based on fuzzy sets. The present approach differs from the earlier one, however, in that (1) it does not require the use of fuzzy sets for the interpretation of linguistic terms, and (2) the meanings of logical inferences are given as algorithms which act directly on terms themselves, rather than on their underlying interpretations. Thus this work constitutes a return to the more purely symbolic or aziomatic representations of logical deduction, whereas the fuzzy-sets model concerns denotational or semantic representations. The new model should not be viewed as a negation of the earlier approaches, however, but as an augmentation of them. The present work is intended as the beginning of a larger system which encompasses both styles of reasoning. Also underway is development of a prototype expert system shell which implements the new model, together with some of the earlier forms of fuzzy inference. This part of the work is being undertaken in part to identify the problems associated with the task of implementation and in this manner demonstrate that implementation is indeed possible. Development of the prototype is also desired so as to experiment with the model and determine its viability as a basis for reasoning in specific problem domains.

The focus of this work was to study large volatile knowledge bases. The research involved developing extensions to logic programming systems in the form of a metalanguage, by studying to what extent frames and semantic nets could be employed. The management of consistency and integrity under change using a metalanguage was analyzed. This research produced a rule-based deductive programming language, called metaProglog, which enhances Prolog's ability to manipulate the databases themselves and to reason about them. This was accomplished by regarding databases (or theories) as first-class objects capable of being passed as arguments. Four papers were published under this grant, including Meta-kavek programming and knowledge representation and metaProlog: A metalevel extension to Prolog. (Author)

During this period, the investigator intended to investigate alternative approaches for improving searching performance in logic programming systems to a level that would be acceptable in a production system by conducting experiments in the LOGLISP system. Due to incompatibilities between the DEC 10 source computer and the CDC CYBER 760 running under NOS, which was available at Florida State University, as well as the differences between the UCI LISP on the DEC 10 and the ALISP available on the CYBER, it was impossible to bring the LOGLISP system to fully operational status and perform the experiments. (Author)

This paper uses logic programming to describe numerical integration in a general way. Axioms are added to the basic logic programs to define specific known numerical integration algorithms. Using a slightly different formalization, we construct logic programs for adaptive Romberg integration and for a new algorithm for adaptive integration. The logic programs provide a formal basis for classifying numerical quadrature algorithms (recall Rice's comment that there are 1,000,000 useful ones). The logic programs are also more understandable than the corresponding programs in conventional programming languages. In terms of logic programming there are several novel points in this paper. The data type, real number, is not definded by a recursive constructor function. Termination is decided by error bounds, rather than by reaching some basis case of the data constructor. The problem itself seems to demand concurrent execution and global variables but in fact is solved in a linear fashion. (Author)

This paper uses logic programming to describe numerical integration in a general way. Axioms are added to the basic logic programs to define specific known numerical integration algorithms. Using a slightly different formalization, we construct logic programs for adaptive Romberg integration and for a new algorithm for adaptive integration. The logic programs provide a formal basis for classifying numerical quadrature algorithms (recall Rice's comment that there are 1,000,000 useful ones). The logic programs are also more understandable than the corresponding programs in conventional programming languages. In terms of logic programming there are several novel points in this paper. The data type, real number, is not definded by a recursive constructor function. Termination is decided by error bounds, rather than by reaching some basis case of the data constructor. The problem itself seems to demand concurrent execution and global variables but in fact is solved in a linear fashion. (Author)

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

We propose a method to adapt functional logic programming to deal with reasoning on coinductively interpreted programs as well as on inductively interpreted programs. In order to do so, we consider a class of objects interesting for this coinductive interpretation, namely regular terms. We show how the usual data structures can be adapted to capture these objects. We adapt the operational semantics of Curry to interpret programs coinductively. We illustrate this method with several examples that show the working of our method and several cases in which it could be useful. Finally, we suggest how the declarative semantics can be adapted suitably.

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

Progress in Artificial Intelligence: Knowledge Extraction, Multi-agent Systems, Logic Programming, and Constraint Solving 10th Portuguese Conference on Artificial Intelligence, EPIA 2001 Porto, Portugal, December 17–20, 2001 Proceedings Author: Pavel Brazdil, Alípio Jorge Published by Springer Berlin Heidelberg ISBN: 978-3-540-43030-8 DOI: 10.1007/3-540-45329-6 Table of Contents: Agent Programming in Ciao Prolog Multi-relational Data Mining: A Perspective A Comparison of GLOWER and Other Machine Learning Methods for Investment Decision Making Parallel Implementation of Decision Tree Learning Algorithms Reducing Rankings of Classifiers by Eliminating Redundant Classifiers Non-parametric Nearest Neighbor with Local Adaptation Selection Restrictions Acquisition from Corpora Classification Rule Learning with APRIORI-C Proportional Membership in Fuzzy Clustering as a Model of Ideal Types Evolution of Cubic Spline Activation Functions for Artificial Neural Networks Multilingual Document Clustering, Topic Extraction and Data Transformations Sampling-Based Relative Landmarks: Systematically Test-Driving Algorithms before Choosing Recursive Adaptive ECOC models A Study on End-Cut Preference in Least Squares Regression Trees The Use of Domain Knowledge in Feature Construction for Financial Time Series Prediction Optimizing the Sharpe Ratio for a Rank Based Trading System Choice: The Key for Autonomy Dynamic Evaluation of Coordination Mechanisms for Autonomous Agents Evolving Multi-agent Viewpoints — An Architecture Enabling Agents to Update Their Knowledge and to Prefer

45 p. 28 cm

45 p. 28 cm

45 p. 28 cm

We have designed a new logic programming language called LM (Linear Meld) for programming graph-based algorithms in a declarative fashion. Our language is based on linear logic, an expressive logical system where logical facts can be consumed. Because LM integrates both classical and linear logic, LM tends to be more expressive than other logic programming languages. LM programs are naturally concurrent because facts are partitioned by nodes of a graph data structure. Computation is performed at the node level while communication happens between connected nodes. In this paper, we present the syntax and operational semantics of our language and illustrate its use through a number of examples.

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.

Logic Programming languages and combinational circuit synthesis tools share a common "combinatorial search over logic formulae" background. This paper attempts to reconnect the two fields with a fresh look at Prolog encodings for the combinatorial objects involved in circuit synthesis. While benefiting from Prolog's fast unification algorithm and built-in backtracking mechanism, efficiency of our search algorithm is ensured by using parallel bitstring operations together with logic variable equality propagation, as a mapping mechanism from primary inputs to the leaves of candidate Leaf-DAGs implementing a combinational circuit specification. After an exhaustive expressiveness comparison of various minimal libraries, a surprising first-runner, Strict Boolean Inequality "

The paper introduces fuzzy linguistic logic programming, which is a combination of fuzzy logic programming, introduced by P. Vojtas, and hedge algebras in order to facilitate the representation and reasoning on human knowledge expressed in natural languages. In fuzzy linguistic logic programming, truth values are linguistic ones, e.g., VeryTrue, VeryProbablyTrue, and LittleFalse, taken from a hedge algebra of a linguistic truth variable, and linguistic hedges (modifiers) can be used as unary connectives in formulae. This is motivated by the fact that humans reason mostly in terms of linguistic terms rather than in terms of numbers, and linguistic hedges are often used in natural languages to express different levels of emphasis. The paper presents: (i) the language of fuzzy linguistic logic programming; (ii) a declarative semantics in terms of Herbrand interpretations and models; (iii) a procedural semantics which directly manipulates linguistic terms to compute a lower bound to the truth value of a query, and proves its soundness; (iv) a fixpoint semantics of logic programs, and based on it, proves the completeness of the procedural semantics; (v) several applications of fuzzy linguistic logic programming; and (vi) an idea of implementing a system to execute fuzzy linguistic logic programs.

Soft Constraint Logic Programming is a natural and flexible declarative programming formalism, which allows to model and solve real-life problems involving constraints of different types. In this paper, after providing a slightly more general and elegant presentation of the framework, we show how we can apply it to the e-mobility problem of coordinating electric vehicles in order to overcome both energetic and temporal constraints and so to reduce their running cost. In particular, we focus on the journey optimization sub-problem, considering sequences of trips from a user's appointment to another one. Solutions provide the best alternatives in terms of time and energy consumption, including route sequences and possible charging events.

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 model theory of a first-order logic called N^4 is introduced. N^4 does not eliminate double negations, as classical logic does, but instead reduces fourfold negations. N^4 is very close to classical logic: N^4 has two truth values; implications in N^4 are material, like in classical logic; and negation distributes over compound formulas in N^4 as it does in classical logic. Results suggest that the semantics of normal logic programs is conveniently formalized in N^4: Classical logic Herbrand interpretations generalize straightforwardly to N^4; the classical minimal Herbrand model of a positive logic program coincides with its unique minimal N^4 Herbrand model; the stable models of a normal logic program and its so-called complete minimal N^4 Herbrand models coincide.

We propose a general framework for first-order functional logic programming, supporting lazy functions, non-determinism and polymorphic datatypes whose data constructors obey a set C of equational axioms. On top of a given C, we specify a program as a set R of C-based conditional rewriting rules for defined functions. We argue that equational logic does not supply the proper semantics for such programs. Therefore, we present an alternative logic which includes C-based rewriting calculi and a notion of model. We get soundness and completeness for C-based rewriting w.r.t. models, existence of free models for all programs, and type preservation results. As operational semantics, we develop a sound and complete procedure for goal solving, which is based on the combination of lazy narrowing with unification modulo C. Our framework is quite expressive for many purposes, such as solving action and change problems, or realizing the GAMMA computation model.

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

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

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

From the bitsavers.org collection, a scanned-in computer-related document. univac :: military :: incrementalComputer :: PX56-4 Incremental Computer Logic and Programming Oct56

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/

Includes index

From the bitsavers.org collection, a scanned-in computer-related document. interdata :: periph :: 47-056R00 35-080 Universal Logic Interface Theory of Operation and Programming 1983

Includes bibliographies

Includes bibliographies

The Journal of Logic Programming 1991: Volume 11 , Issue Index. Digitized from IA1652909-07 . Previous issue: sim_journal-of-logic-and-algebraic-programming_april-may-1991_10_3-4 . Next issue: sim_journal-of-logic-and-algebraic-programming_1991_11_contents .

We are proud to introduce this special issue of the Journal of Theory and Practice of Logic Programming (TPLP), dedicated to the full papers accepted for the 28th International Conference on Logic Programming (ICLP). The ICLP meetings started in Marseille in 1982 and since then constitute the main venue for presenting and discussing work in the area of logic programming.

There are various interesting semantics' (extensions) designed for argumentation frameworks. They enable to assign a meaning, e.g., to odd-length cycles. Our main motivation is to transfer semantics' proposed by Baroni, Giacomin and Guida for argumetation frameworks with odd-length cycles to logic programs with odd-length cycles through default negation. The developed construction is even stronger. For a given logic program an argumentation framework is defined. The construction enables to transfer each semantics of the resulting argumentation framework to a semantics of the given logic program. Weak points of the construction are discussed and some future continuations of this approach are outlined.

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

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.

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)

This paper describes applications of logic programming technology to the teaching of the inductive method in computer science and mathematics. It discusses the nature of inductive thought and its place in those fields of inquiry, arguing that a complete logic programming system for supporting inductive inference is not only feasible but necessary. A sample dialog from the Prologb system is included, along with an overview of the Prologb language and some details about classroom experiences using the system. (Author/BEW)

This paper describes applications of logic programming technology to the teaching of the inductive method in computer science and mathematics. It discusses the nature of inductive thought and its place in those fields of inquiry, arguing that a complete logic programming system for supporting inductive inference is not only feasible but necessary. A sample dialog from the Prologb system is included, along with an overview of the Prologb language and some details about classroom experiences using the system. (Author/BEW)

This paper describes applications of logic programming technology to the teaching of the inductive method in computer science and mathematics. It discusses the nature of inductive thought and its place in those fields of inquiry, arguing that a complete logic programming system for supporting inductive inference is not only feasible but necessary. A sample dialog from the Prologb system is included, along with an overview of the Prologb language and some details about classroom experiences using the system. (Author/BEW)