Type declarations as subtype constraints in logic programming

Knowledge Representation Methods for Dairy Decision Support Systems

A methodology for developing sound proof systems for program verification is demonstrated by the development of a proof system for reasoning about concurrent programs based on the unity logic of K.M. Chandy and J. Misra (1988). This proof system has been validated by an automated theorem prover, a computer program that checks the correctness of proofs. The Boyer-Moore logic in which the proof system is formalized and the Boyer-Moore theorem prover which mechanizes this logic are described. The motivation behind the unity logic and the way in which it may be used to prove the correctness of concurrent programs are examined. A proof system for concurrent programs based on the unity logic system is provided as an example. An operational semantics of concurrency is formalized in Boyer-Moore logic by use of the transition system model. Unity's proof rules are proved as theorems about this operational semantics. The proofs of these theorems are mechanically checked. The entire proof system has been verified by the Boyer-Moore prover, making it possible to prove mechanically the consequence of other concurrent programs.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Sound over-approximation methods are effective for proving the absence of errors, but inevitably produce false alarms that can hamper programmers. In contrast, under-approximation methods focus on bug detection and are free from false alarms. In this work, we present two novel proof systems designed to locate the source of errors via backward under-approximation, namely Sufficient Incorrectness Logic (SIL) and its specialization for handling memory errors, called Separation SIL. The SIL proof system is minimal, sound and complete for Lisbon triples, enabling a detailed comparison of triple-based program logics across various dimensions, including negation, approximation, execution order, and analysis objectives. More importantly, SIL lays the foundation for our main technical contribution, by distilling the inference rules of Separation SIL, a sound and (relatively) complete proof system for automated backward reasoning in programs involving pointers and dynamic memory allocation. The completeness result for Separation SIL relies on a careful crafting of both the assertion language and the rules for atomic commands.

In this paper, we discuss the computational complexity of Read-once resolution (ROR) with respect to Horn formulas. Recall that a Horn formula is a boolean formula in conjunctive normal form (CNF), such that each clause has at most one positive literal. Horn formulas find applications in a number of domains such as program verification and logic programming. It is well-known that deduction in ProLog is based on unification, which in turn is based on resolution and instantiation. Resolution is a sound and complete procedure to check whether a boolean formula in CNF is satisfiable. Although inefficient in general, resolution has been used widely in theorem provers, on account of its simplicity and ease of implementation. This paper focuses on two variants of resolution, viz., Read-once resolution and Unit Read-once resolution (UROR). Both these variants are sound, but incomplete. In this paper, the goal is to check for the existence of proofs (refutations) of Horn formulas under these variants. We also discuss the computational complexity of determining optimal length proofs where appropriate.

A scheme for fuzzy temporal knowledge representation and reasoning is proposed. The scheme is based on the modification of the Petri nets called fuzzy time Petri nets and fuzzy temporal relations. The reasoning process uses modified Petri nets theory, possibility theory and a fuzzified version of Allen's (1983) temporal relations. The temporal linguistic expressions are modelled by primitives derived from the knowledge representation scheme. By combining and connecting these primitives the complex forms of situations from fuzzy temporal rich domains are modelled. An example of the use of the proposed scheme is given.

We introduce a sound non-wellfounded proof system whose regular (or ‘cyclic’) proofs are complete for (in)equations between regular expressions. We achieve regularity by using hypersequents rather than usual sequents, with more structure in the succedent, and relying on the discreteness of rational languages to drive proof search. By inspection of the proof search space we extract a PSpace bound for the system, which is optimal for deciding such (in)equations.

This paper presents a sound and complete proof system for the logical system whose sentences are of the form AllXareY, Some X are Y and Most X are Y, where we interpret these sentences on finite models, with the meaning of “most” being “strictly more than half.” Our proof system is syllogistic; there are no individual variables.

Research by myself and by others has shown that there are natural programming language control structures that are impossible to describe adequately by means of Hoare axioms. Specifically, we have shown that there are control structures for which it is impossible to obtain axiom systems that are sound and relatively complete in the sense of Cook. These constructs include procedures with procedure parameters under standard ALGOL 60 scope rules and coroutines in a language with parameterless recursive procedures. A natural question to ask is whether it is possible to characterize those programming languages for which sound and complete proof systems can be obtained. For a wide class of programming languages and interpretations, it can be shown that P has a sound and relatively complete proof system for every expressive interpretation iff the halting problem for language P is decidable for all finite interpretations. Nevertheless, we are still far from a completely satisfactory characterization of the programming languages that can be axiomatized in this manner. The proof system that is generated in proving the above result does not have the property of being ‘syntax-directed’, which is distinctive of the Hoare axioms. Moreoever, theoretical considerations suggest that good axioms for total correctness may exist for a wider spectrum of languages than for partial correctness. In this paper we discuss these questions and others that still need to be addressed before the characterization problem can be considered solved.

Counterexamples produced by model checkers can be hard to grasp. Often it is not even evident why a trace violates a specification. We show how to provide easy-to-check evidence for the violation of a linear temporal logic (LTL) formula on a lasso word, based on a novel sound and complete proof system for LTL on lasso words. Valid proof trees in our proof system follow the syntactic structure of the formula and provide insight on why each Boolean or temporal operator is violated or satisfied. We introduce the notion of optimal proofs with respect to a user-specified preference order and identify sufficient conditions for efficiently computing optimal proofs. We design and evaluate an algorithm that performs this computation, demonstrating that it can produce optimal proofs for complex formulas in under a second.

A fundamental requirement to achieve effectiveness in a medical expert system is the proper representation of knowledge about a patient. Knowledge about a patient is stored in the expert system in terms of clinical records which should contain information about multiple visits of the patient. During each visit, several conversations are made between the patient and the consulting physician. These conversations, being unstructured in nature, cannot be stored in the computer using available structured knowledge representation schemes. So, we propose a recursive frame-based structure for representing clinical records. The frames related to a patient collectively form a frame system, where one frame may point to other frames. The proposed representation scheme is complete, consistent, and free from redundancy.

Logic programming is a language paradigm based on logic, more specifically on resolution theorem proving in the predicate calculus as proposed in Robinson [1965]. Robinson had the foresight to distinguish the importance of two components in automatic theorem proving: a single inference rule called resolution and the testing for equality of trees called unification. Resolution is an inference step used to prove the validity of predicate calculus formulas expressed as clauses. In its simplest version: P ~ Q and -P ~ R imply Q ~ R, which is called the resolvant. Unification is the matching of terms used in a resolution step. It consists of testing the satisfiability of the equality of terms (i.e., labeled trees) whose leaves may contain variables. For example, the unification of the terms p(X, q(Z, a)) and p(b, q(a, Y)) succeeds, yielding the bindings X 5 b, Z 5 a, and Y 5 a. Prolog, the main representative of LP, consists of a sequence of Horn clauses. A Horn clause is one containing (at most) one positive literal. The term definite clause is used to denote a clause with exactly one positive literal. Prolog programs can be viewed as a set of definite clauses in which the positive literal is the head of the rule and the negative literals constitute the body or tail of the rule. From a procedural point of view, a head corresponds to the definition of a Boolean function whose body consists of conjunctions of calls to the Boolean functions representing the tail [Kowalski 1979]. A quintessential example of a Prolog program is that of append. It consists of two Horn clauses specifying that list L3 is the concatenation of two lists, L1 and L2:

In order to provide performance improvements in the execution of large logic programs, it is highly desirable to investigate the relationships between logic, data-base systems and knowledge-based systems in the context of massively parallel architectures. This paper presents a model for the interpretation of logic programs in this type of environment and overviews the algorithms under development. An interpreter that implements the model has been demonstrated in simulations on a number of small programs. Implementation requires only a small set of hardware primitives be available, these have been successfully implemented on a working prototype machines. DADO Current research aims to develop the model into a practical and efficient logic programming system for use on the machine.

Based on a detained discussion of system architectures for knowledge based speech understanding and knowledge representation techniques, criteria for both a knowledge representation scheme and system architectures are developed. Upon this background a system is introduced which is organized around a homogenuous knowledge base. Both the knowledge representation language and the content of the knowledge base are described. The knowledge representation language do not only cover declarative but also procedural knowledge. Analysis processes are guided by a flexibel bottom-up top-down strategy. Besides the procedural semantics of the language the A -Algorithm is used for this purpose. Search graph nodes are judged by a vector which reflects knowledge dependent and acoustic scores and which is admissable for the A -Algorithm.

It has been claimed that logic programs are equivalent to or consequences of specifications. We argue this is generally not correct. Programs often make implicit assumptions about types, leading to the possibility of incorrect answers. If the assumptions are made explicit, so that the program is equivalent to the specification, the program is less efficient. We define when programs with type declarations are type correct and show all well typed answers returned by such programs are correct.

Engineering design essentially consists of generating specifications for the artifact being designed. It involves complex tasks of generating various feasible solutions and critically evaluating them. Developing knowledge-based systems (KBSs) requires adopting proper knowledge organization, representation schemes and suitable problem-solving techniques, which depend on the nature of the design task and type of knowledge involved. This paper presents one such exercise carried out in the domain of bridge engineering design. A design process model, comprising of rule-based inference, solution generation (synthesis) and evaluation (criticism) tools, is proposed based on the methodologies adopted by bridge design experts. The development of a KBS for the conceptual design of concrete road bridges is then described including the knowledge involved, its organization and representation schemes. Working of the KBS is explained through an application example. The main thrust of this-paper is on the critical evaluation of various generated feasible solutions.