Temporal logic programming for assembly sequence planning

A temporal-constraint logic programming framework for the specification and automatic verification and synthesis of assembly sequences is developed. The implemented tool is based on the formulated and derived precedence properties for a general mechanical assembly. This tool, called the Mechanical Assembly Sequence Satisfiability Checker (MASS-C), supports the use of a subset of temporal logic for assembly constraint specification. MASS-C provides the logic programming framework by which the designer can be relieved of the tedium of finding the assembly sequences, and the assembly sequence planning process manifests itself in the implicit modelling of assembly sequences by acquiring and formulating the set of correct and complete assembly constraints as a logic program. MASS-C implements a class of temporal expressions as predicates for logic programming of assembly constraints. It provides facilities to either verify an assembly sequence or synthesise all assembly sequences that satisfy the specified constraints composed as a logic program. Two examples illustrate the use of MASS-C for such verification and synthesis.     

Towards efficient partial evaluation in logic programming

Partial evaluation is a symbolic manipulation technique used to produce efficient algorithms when part of the input to the algorithm is known. Other applications of partial evaluators such as universal compilation and compiler generation are also known to be possible. A partial evaluator receives as input a program and partially known input to that program, and outputs a residual program which should run at least as efficient as the input program with restricted input. In this paper we study the case where both the input and residual programs are logic programs, being the partial evaluator itself a logic program. Up to now, partial evaluators have failed to process large “non=toy” examples. Here we present extensions to partial evaluators whic will allow us to produce more efficient residual programs using less computing resources, during partial evaluation. First, the introduced extensions allow the processing of large examples, which is not possible with the previous techniques. This is now possible since the extensions use less CPU time and memory consumption during the partial evaluation process. Second, the extended partial evaluator produces smaller residual programs, producing important CPU time optimizing effects. With the standard techniques, a partial evaluator will most probably act as a pessimizer, not as an optimizer. Examples are given.     

A logic programming framework for planning and simulation

Planning and simulation models share the characteristic that they involve reasoning about hypothetical sequences of activities. These may be naturally described in a graph structure, e.g., a state transition diagram or a Petri net. A logic programming framework is proposed for describing the problem domain (‘model base’) of planning and simulation problems in logical form, separate from the inferencing mechanisms applied to them. Applications are to dynamic programming, decision trees, PERT networks, and discrete event simulation.     

Developing control logic using aspect-oriented programming and sequence planning

A fundamental functionality of a Programmable Logic Controller (PLC) is to control and execute a set of operations. But a large part of the program code is more involved in supporting the user with concerns like alarm, HMI, communication, safety and manual control. Code related to these supporting concerns is often tangled with operation execution code, the core concerns, which makes it hard to reuse.This paper describes a method to reuse code and functionality when developing PLC programs and code libraries. The method proposes that core concerns are planned with a software tool called Sequence Planner, and the supporting concerns are integrated into the core concerns with a tool based on aspect-oriented programming.     

Integrating answer set programming and constraint logic programming

We introduce a knowledge representation language ${\cal AC(C)}$ extending the syntax and semantics of ASP and CR-Prolog, give some examples of its use, and present an algorithm, $\mathcal{AC}\!solver$ , for computing answer sets of ${\cal AC(C)}$ programs. The algorithm does not require full grounding of a program and combines “classical” ASP solving methods with constraint logic programming techniques and CR-Prolog based abduction. The ${\cal AC(C)}$ based approach often allows to solve problems which are impossible to solve by more traditional ASP solving techniques. We believe that further investigation of the language and development of more efficient and reliable solvers for its programs can help to substantially expand the domain of applicability of the answer set programming paradigm.     

Translations and similarity-based logic programming

In order to provide approximate reasoning capabilities, in Gerla G, Sessa MI (1999) Chen G, Ying M, Cai K-Y (Eds) Fuzzy Logic and Soft computing, 19–31, Kluwer Academic Publishers, Boston an extension of Logic Programming has been proposed. Logic programs on function-free languages are considered, and approximate and imprecise information are represented by introducing a similarity relation ? in the set of predicate names and object names of the language. The inference system exploits the classical resolution rule of the Logic Programming paradigm. Moreover, the notion of fuzzy least Herbrand model is also provided. In this paper, by introducing the general notion of structural translation of languages, we generalize these results to the case of logic programs with function symbols. Some properties of the similarity relations are also proven.     

Regulation management and logic programming

Regulations are pervasive in information systems. They manifest themselves as design rules, integrity constraints, deadlines, conventions, information disclosure requirements, policies, procedures, contracts, taxes, quotas and other statutes. Managing regulations is difficult. Regulations are complex, change frequently and rest on models of the real world that involve unusual vocabulary if not unusual concepts. Consequently, checking compliance with regulations is tedious and error-prone. Logic programming appears to provide a good framework for developing regulation management systems. Besides permitting arbitrary regulations to be modelled, it offers rapidity and ease of development, readability, incremental modifiability, extensibility and portability. These features are not provided by existing DP programming tools, database managers or conventional expert-system shells. This paper investigates the application of logic programming in a significant regulation management application: Workers' Compensation Insurance premium auditing. The insurance premium computation rules for the State of California were encoded as a large Prolog program. This application illustrates specific strengths and weaknesses of logic programming and Prolog in dealing with large-scale real-world regulations.     

Integrating logic and functional programming

The intent of this article is twofold: To survey prominent proposals for the integration of logic and functional programming and to present a new paradigm for the same purpose. We categorize current research into four types of approaches, depending on the level at which the proposed integration is achieved. Unlike most current work, our approach is not based on extending unification to general-purpose equation solving. Rather, we propose a computation delaying mechanism calledresiduation. This allows a clear distinction between functionalevaluation and logicaldeduction. The former is based on the-calculus, and the latter on Horn clause resolution. Residuation is built into the unification operation which may then account for-reduction. In clear contrast with equation-solving approaches, our model supports higher-order function evaluation and efficient compilation of both functional and logic programming expressions, without being plagued by non-deterministic term-rewriting. In addition, residuation lends itself naturally to process synchronization and constrained search. We describe an operational semantics and an implementation of a prototype language called LeFun—Logic, equations, and Functions.This article is a revised and extended version of [1].     

Defeasible reasoning and logic programming

The general conditions of epistemic defeat are naturally represented through the interplay of two distinct kinds of entailment, deductive and defeasible. Many of the current approaches to modeling defeasible reasoning seek to define defeasible entailment via model-theoretic notions like truth and satisfiability, which, I argue, fails to capture this fundamental distinction between truthpreserving and justification-preserving entailments. I present an alternative account of defeasible entailment and show how logic programming offers a paradigm in which the distinction can be captured, allowing for the modeling of a larger range of types of defeat. This is possible through a natural extension of the declarative and procedural semantics of Horn clauses.     

Overview of disjunctive logic programming

The field of disjunctive programming started approximately in 1982 and has reached its first decade. The first result in the field was the development of the Generalized Closed World Assumption (GCWA). Major results have been made in this field since 1986. An overview is presented of the developments that have taken place, which include model theoretic, proof theoretic and fixpoint semantics for disjunctive, and extended normal disjunctive theories including alternative forms of negation.Dedicated to Chitta Baral, José Alberto Fernández, Jorge Lobo and Arcot Rajasekar.     

About classical logic and imperative programming

We consider a -calculus system in second-orderclassical logic, in which execution of -terms is weak head reduction (call-by-name). By means of some simple examples, we show how it can modelize some aspects of imperative programming languages, such as assignment and escape instructions. A crucial tool is the notion ofstorage operator, for which a simple type is given.     

Modularization and abstraction in logic programming

In knowledge information processing, the structuring of knowledge and algorithms is one of the key issues. The goal of this work is to introduce the concepts and mechanisms of abstraction, modularization and parameterization into logic programming, which is one of the preliminary steps toward creating a kernel language for fifth generation computer systems.     

Many-valued logic and mixed integer programming

We generalize prepositional semantic tableaux for classical and many-valued logics toconstraint tableaux. We show that this technique is a generalization of the standard translation from CNF formulas into integer programming. The main advantages are (i) a relatively efficient satisfiability checking procedure for classical, finitely-valued and, for the first time, for a wide range of infinitely-valued propositional logics; (ii) easy NP-containment proofs for many-valued logics. The standard translation of two-valued CNF formulas into integer programs and Tseitin's structure preserving clause form translation are obtained as a special case of our approach.Part of the research reported here was carried out while the author was supported by a grant within the DFG Schwerpunktprogramm Deduktion. Preliminary and partial versions of this paper were published as [15, 16].     

粗糙逻辑中理论相容性的拓扑刻画

有关文献将计量化方法应用于粗糙逻辑之中,建立起了用以处理近似推理问题的粗糙逻辑度量空间理论。拟借助于粗糙逻辑度量空间理论,从拓扑学的角度给出粗糙逻辑理论相容性的等价刻画。     

Relating the implementation techniques of functional and functional logic languages

Functional logic languages are declarative programming languages that integrate the programming paradigms of functional and logic languages within a single framework. They are extensions of functional languages with principles derived from logic programmingNarrowing, the evaluation mechanism of functional logic languages, can be defined as a generalization ofreduction, the evaluation mechanism of purely functional languages. The unidirectional pattern matching, which is used for parameter passing in functional languages, is simply replaced by the bidirectionalunification known from logic programming languages. We show in this paper, how to extend a reduction machine, that has been designed for the evaluation of purely functional programs to a machine that performs narrowing. The necessary extensions concern the realization of unification and backtracking, for which we fall back upon the methods of Warren’s Prolog engine.²¹⁾ The narrowing machine embodies an optimized treatment of deterministic computations. A complete specification of the reduction and the narrowing machine and of the translation of a sample language into abstract machine code is given. Comparative results of a C-implementation of the reduction and the narrowing machine show that the time overhead of the more complex narrowing evaluation is, in general, less than 10% of the reduction evaluation.