First order programming logic

The problem of reasoning about recursive programs is considered. Utilizing a simple analogy between iterative and recursive programs viewed as unfinite unions of finite terms, we carry out an investigation analogous to that carried out recently for iterative programs. The main results are the arithmetical completeness of axiom systems for (1) context-free dynamic logic and (2) its extension for dealing with infinite computations. Having the power of expression of these logics in mind, these results can be seen to supply (as corollaries) complete proof methods for the various kinds of correctness of recursive programs.

Transformation-based program verification was a very important topic in early years of theory of programming. Great computer scientists contributed to these studies: John McCarthy, Amir Pnueli, Donald Knuth ... Many fascinating examples were examined and resulted in recursion elimination techniques known as tail-recursion and co-recursion. In the paper, we examine just a single example (but new we hope) of recursion elimination via program manipulations and problem analysis. The recursion pattern of the example matches descending dynamic programming but is neither tail-recursion nor corecursion pattern. Also, the example may be considered from different perspectives: as a transformation of a descending dynamic programming to ascending one (with a fixed-size static memory), or as a proof of the functional equivalence between recursive and iterative programs (that can later serve as a casestudy for automatic theorem proving), or just as a fascinating algorithmic puzzle for fun and exercising in algorithm design, analysis, and verification. The article is published in the author’s wording.

Separation logic was developed as an extension to Hoare logic with the aim of simplifying pointer program proofs. A key feature of the logic is that it focuses the reasoning effort on only those parts of the heap that are relevant to a program - so called local reasoning. Underpinning this local reasoning are the separating conjunction and separating implication operators. Here we present an automated reasoning technique called mutation that provides guidance for separation logic proofs. Specifically, given two heap structures specified within separation logic, mutation attempts to construct an equivalence proof using a difference reduction strategy. Pivotal to this strategy is a generalised decomposition operator which is essential when matching heap structures. We show how mutation provides an effective strategy for proving the functional correctness of iterative and recursive programs within the context of weakest precondition analysis. Currently, mutation is implemented as a proof plan within our CORE program verification system. CORE combines results from shape analysis with our work on invariant generation and proof planning. We present our results for mutation within the context of the CORE system.KeywordsCore SystemSeparation LogicFunctional CorrectnessRecursive ProgramLoop InvariantThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

The programmable logic unit (PLU) has been proposed to realize a high‐speed operation. The idea is to perform computation obtained by a static data flow scheme using the stepwise arithmetic logics distributed in the memory. This paper describes the configuration of the prototype PLU, the basic concepts of the computation and the synchronization between the PLU and the main control unit (CU). Then theoretical discussions are made on the computation time for the arithmetic and the iterative programs. It is shown that the high‐speed processing is realized by the effects of the parallel computation and of the pipelined computation, mapping many templates of a loop program on the PLU. Furthermore, the multiprogramming for the computer with PLU is proposed to utilize effectively the waiting time for the computation in the PLU. The throughput improvement is indicated by theoertical analysis, comparing the computer using PLU with the traditional sequential computer. Finally, the usefulness of the PLU is demonstrated.

Clark and Tarnlud4 have proposed a methodology for the specification, desing and verification of logic programs in the framework of first order logic. Their main idea is to derive the correctness of a logic program from its own clauses and suitable induction axioma on the data. This approach has been also advocated by Cartwright3 for the case of recursive, functional programs. He has contributed some theoretical results about the semantics of programs in nonstandard structures, using the notion of least definable fixpoint of the operator naturally associated to a given recursive program: This idea is also implicit in the independent work of Andreka, Nemeti and Sain1 and Hajek7 about nonstandard dynamic logic for flowchart-like programs and regular programs; see also Sain10.

Guest Editorial: Situational awareness of integrated energy systems

An autoepistemic logic programming language is derived from a subset of a three-valued autoepistemic logic, called 3AEL. Autoepistemic programs generalize several ideas underlying logic programming: stable, supported, and well-founded models, Fitting's semantics, Kunen's semantics, and abductive frameworks can all be captured through simple autoepistemic translations; moreover, SLDNF-resolution and a generate-and-test method for stable semantics are generalized to provide sound and complete proof methods for autoepistemic programs. These methods extend existing proof methods for 3AEL. Thus autoepistemic logic programming, besides contributing to the understanding of 3AEL, can be seen as a unifying framework for the theory of logic programs. It should also be regarded as a first step toward a flexible environment where different forms of inference can be formally integrated.

Modern information technology makes it possible today to collect, store, transfer, and combine huge amounts of data at very low costs. Thus more and more companies, and scientific and governmental institutions build up large archives of all kinds of data like numbers, tables, documents, images, sounds, etc. Although users often have a vague understanding of their data and can usually formulate hypotheses and guess dependencies, turning these – often abundantly available – data into useful information turns out to be rather difficult. In response to these challenges a new area of research has emerged, called ‘‘knowledge discovery in databases’’ or ‘‘data mining’’, that tries to provide tools to extract valid, useful, understandable, unknown, and unexpected relationships from large databases [1]. This current form of data analysis is an interdisciplinary field, and employs methods from statistics, soft computing, artificial intelligence and machine learning. The stress lies on the development of techniques that produce human-understandable results, and are suited for large, real world datasets. The data in real world applications has in most cases characteristics that challenge classical analyzing approaches. Besides being heterogeneous – which in its simplest form can mean that we have to deal with numerical and symbolic features – , the data is often of low quality. Algorithms must thus be able to deal with uncertainty and imprecision. The characteristics of the data sources – their quantity, complexity, dimensionality and imperfection – , the essential of extracting understandable patterns from these, and the need to incorporate available background knowledge in that process, makes us assume that (neuro-) fuzzy techniques will play a considerable role in the future of data mining [3]. It is the ability of fuzzy sets to transform between computer representations and (naturally linguistic) human concepts that makes them so valuable to meet the advanced data mining demands, and that Zadeh meant, when he promoted his idea of computing with words [4]. The inherent imprecision of words is not necessarily a weakness, but, on the contrary, can be crucial to model complex systems. From our own experience we observed that many practical applications have this certain robustness where full precision is not necessary. In such cases, exaggerated precision can be a waste of resources, and solutions obtained using fuzzy approaches might be easier to understand and to apply, and gain their strengths by explicitly taking into account vagueness, imprecision or uncertainty. One prominent way to use fuzzy systems in data analysis, is to induce fuzzy if-then rules from data by neurofuzzy techniques. The use of linguistic variables eases the readability and interpretability of the rule base. If we apply such techniques, we must be aware of the trade-off between precision and interpretability. However, the results in data mining are not only judged for their accuracy, but also for their interpretability, as the ultimate goal is to extract human understandable patterns [2]. The papers in this special issue of the Soft Computing Journal deal with quite different aspects of neuro-fuzzy techniques, with a stress on data analysis and rule based systems. Although the intention of this issue cannot be to give a survey of this wide area, it shall give an insight in current trends and research topics in this field. The papers can roughly be divided into three groups:

Motivated by the problem of building a basic reasoner for general game playing with imperfect information, we address the problem of filtering with logic programs, whereby an agent updates its incomplete knowledge of a program by observations. We develop a filtering method by adapting an existing backward-chaining and abduction method for so-called open logic programs. Experimental results show that this provides a basic effective and efficient "legal" player for general imperfect-information games.

There is a tension between the objectives of avoiding irrelevant computation and extracting parallelism, in that a computational step used to restrict another must precede the latter. Our thesis, following [3], is that evaluation methods can be viewed as implementing a choice ofsideways information propagation graphs, or sips, which determines the set of goals and facts that must be evaluated. Two evaluation methods that implement the same sips can then be compared to see which obtains a greater degree of parallelism, and we provide a formal measure of parallelism to make this comparison. Using this measure, we prove that transforming a program using the Magic Templates algorithm and then evaluating the fixpoint bottom-up provides a “most parallel” implementation for a given choice of sips, without taking resource constraints into account. This result, taken in conjunction with earlier results from [3,27], which show that bottom-up evaluation performs no irrelevant computation and is sound and complete, suggests that a bottom-up approach to parallel evaluation of logic programs is very promising. A more careful analysis of the relative overheads in the top-down and bottom-up evaluation paradigms is needed, however, and we discuss some of the issues. The abstract model allows us to establish several results comparing other proposed parallel evaluation methods in the logic programming and deductive database literature, thereby showing some natural, and sometimes surprising, connections. We consider the limitations of the abstract model and of the proposed bottom-up evaluation method, including the inability of sips to describe certain evaluation methods, and the effect of resource constraints. Our results shed light on the limits of the sip paradigm of computation, which we extend in the process.

Several formal systems, such as resolution and minimal model semantics, provide a framework for logic programming. In this article, we will survey the use ofstructural proof theoryas an alternative foundation. Researchers have been using this foundation for the past 35 years to elevate logic programming from its roots in first-order classical logic into higher-order versions of intuitionistic and linear logic. These more expressive logic programming languages allow for capturing stateful computations and rich forms of abstractions, including higher-order programming, modularity, and abstract data types. Term-level bindings are another kind of abstraction, and these are given an elegant and direct treatment within both proof theory and these extended logic programming languages. Logic programming has also inspired new results in proof theory, such as those involving polarity and focused proofs. These recent results provide a high-level means for presenting the differences between forward-chaining and backward-chaining style inferences. Anchoring logic programming in proof theory has also helped identify its connections and differences with functional programming, deductive databases, and model checking.

The method of recursive quadratic programming, coupled with a homotopy method, has been used to generate approximate minimum-time and minimum tracking-error tip trajectories for two-link flexible manipulator movements in the horizontal plane. The manipulator is modeled with an efficient finite-element scheme for a multi-link, multi-joint system with bending only in the horizontal-plane. Constraints on the trajectory include boundary conditions on link tip position, final joint velocities, accelerations and torque inputs to complete a rest-to-rest maneuver, straight-line tip tracking between boundary positions, and motor torque limits. Trajectory comparisons demonstrate the impact of torque input smoothness on structural mode excitation. Applied torques retain much of the qualitative character of rigid-body slewing motion with alterations for energy dissipation.

Synthesis and transformation of logic programs using unfold/fold proofs

Propositional dynamic logic of nonregular programs

This paper presents an approach to inductive synthesis of logic programs from examples using problem decomposition and problem reduction principles. This is in contrast to the prevailing logic program induction paradigm, which relies on generalization of programs from examples. The problem reduction is accomplished as a constrained top-down search process, which eventually is to reach trivial problems. Our induction scheme applies a distinguished logic programming language in which programs are combined from elementary predicates by means of combinators conceived of as problem reduction operators including list recursion forms. The operator form admits inductive synthesis as a top-down piecewise composition of semantically meaningful program elements according to the compositional semantics principle and with appeals neither to special generalization mechanisms nor to alternative forms of resolution and unification, or predicate invention. The search space is reduced by subjecting the induction process to various constraints concerning syntactical form, modes, data types, and computational resources. This is illustrated in the paper with well-modedness constraints with the aim of synthesising well-moded, procedurally acceptable programs. Preliminary experiments with the proposed induction method lead us to tentatively conclude that the presented approach forms a viable alternative to the prevailing inductive logic programming methods applying generalization from examples.