An Observationally Complete Program Logic for Imperative Higher-Order Frame Rules

Hoare logics are proof systems that allowone to formally establish properties of computer programs. Traditional Hoare logics prove properties of individual program executions (such as functional correctness). Hoare logic has been generalized to prove also properties of multiple executions of a program (so-called hyperproperties, such as determinism or non-interference). These program logics prove the absence of (bad combinations of) executions. On the other hand, program logics similar to Hoare logic have been proposed to disprove program properties (e.g., Incorrectness Logic), by proving the existence of (bad combinations of) executions. All of these logics have in common that they specify program properties using assertions over a fixed number of states, for instance, a single pre- and post-state for functional properties or pairs of pre- and post-states for non-interference. In this paper, we present Hyper Hoare Logic, a generalization of Hoare logic that lifts assertions to properties of arbitrary sets of states. The resulting logic is simple yet expressive: its judgments can express arbitrary program hyperproperties , a particular class of hyperproperties over the set of terminating executions of a program (including properties of individual program executions). By allowing assertions to reason about sets of states, Hyper Hoare Logic can reason about both the absence and the existence of (combinations of) executions, and, thereby, supports both proving and disproving program (hyper-)properties within the same logic, including (hyper-)properties that no existing Hoare logic can express. We prove that Hyper Hoare Logic is sound and complete, and demonstrate that it captures important proof principles naturally. All our technical results have been proved in Isabelle/HOL.

Starting with Hoare Logic over 50 years ago, numerous program logics have been devised to reason about the different kinds of programs encountered in the real world. This includes reasoning about computational effects, particularly those effects that cause the program execution to branch into multiple paths due to, e.g., nondeterministic or probabilistic choice. Outcome Logic reimagines Hoare Logic with branching at its core, using an algebraic representation of choice to capture programs that branch into many outcomes. In this article, we give a comprehensive account of the Outcome Logic metatheory. This includes a relatively complete proof system for Outcome Logic with the ability to reason about general purpose looping. We also show that this proof system applies to programs with various types of branching, that it subsumes some well-known logics such as Hoare Logic, and that it facilitates the reuse of proof fragments across different kinds of specifications.

Logic programming: Laxness and saturation

The goal of The Reasoned Schemer is to help the functional programmer think logically and the logic programmer think functionally. The authors of The Reasoned Schemer believe that logic programming is a natural extension of functional programming, and they demonstrate this by extending the functional language Scheme with logical constructs -- thereby combining the benefits of both styles. The extension encapsulates most of the ideas in the logic programming language Prolog.The pedagogical method of The Reasoned Schemer is a series of questions and answers, which proceed with the characteristic humor that marked The Little Schemer and The Seasoned Schmer. Familiarity with a functional language or with the first eight chapters of The Little Schemer is assumed. Adding logic capabilities required the introduction of new forms. The authors' goal is to show to what extent writing logic programs is the same as writing functional programs using these forms. In this way, the reader of The Reasoned Schemer will come to understand how simple logic programming is and how easy it is to define functions that behave like relations.

The main result of this paper is a normalizing system of natural deduction for the full language of intuitionistic linear logic. No explicit weakening or contraction rules for \(\)-formulas are needed. By the systematic use of general elimination rules a correspondence between normal derivations and cut-free derivations in sequent calculus is obtained. Normalization and the subformula property for normal derivations follow through translation to sequent calculus and cut-elimination.

We introduce an extension of Hoare logic for call-by-value higher-order functions with ML-like local reference generation. Local references may be generated dynamically and exported outside their scope, may store higher-order functions and may be used to construct complex mutable data structures. This primitive is captured logically using a predicate asserting reachability of a reference name from a possibly higher-order datum and quantifiers over hidden references. The logic enjoys three completeness properties: relative completeness, a logical characterisation of the contextual congruence and derivability of characteristic formulae. The axioms for reachability and local invariants play a fundamental role in reasoning about non-trivial programs combining higher-order procedures and dynamically generated references.

The object of this study is the process of automatic formation of fuzzy production rules on the basis of a training sample for solving the classification problem. The problem of automatically creating and then checking the correctness of a fuzzy inference model for a classification task is solved. The result is an automatically constructed correct database of rules for solving the classification problem. Analysis of the correctness of the knowledge base is carried out using the criteria of completeness, minimality, coherence, and consistency. To prove the completeness of the rule base, Hoare logic and the resolution method are used. The quality of the classification is assessed using such metrics as accuracy, precision, recall, f1-score. The dependence of the classification result on the size of the training sample is considered. The expert system has the following features: the ability to learn from data; high level of accuracy; the correct knowledge base. The knowledge base is formed using the objects of the training sample on the basis of linguistic variables and term sets. A production model of knowledge representation is applied, combining the Mamdani and Takagi-Sugeno-Kang models. It is assumed that the left parts of the production rules describe combinations of the features of objects, and the right parts correspond to classes. The matrix representation of the antecedents of the rules is used. Consequents are represented as a column vector. For the automatic construction of the matrix of antecedents, it is proposed to use the Cartesian product. The formation of the consequent vector is carried out automatically using domain data and a training procedure. The resulting expert system can be used to solve the problems of classification, clustering, data mining, and big data analysis

By combining program logic and static analysis, we present an automatic approach to construct program proofs to be used in Proof-Carrying Code. We use Hoare logic in representing the proofs of program properties, and the abstract interpretation in computing the program properties. This combination automatizes proof construction; an abstract interpretation automatically estimates program properties (approximate invariants) of our interest, and our proof-construction method constructs a Hoare-proof for those approximate invariants. The proof-checking side (code consumer’s side) is insensitive to a specific static analysis; the assertions in the Hoare proofs are always first-order logic formulas for integers, into which we first compile the abstract interpreters’ results. Both the property-compilation and the proof construction refer to the standard safety conditions that are prescribed in the abstract interpretation framework. We demonstrate this approach for a simple imperative language with an example property being the integer ranges of program variables. We prove the correctness of our approach, and analyze the size complexity of the generated proofs.

Determining inference semantics for disjunctive logic programs

In massively collaborative projects such as scientific or community databases, users often need to agree or disagree on the content of individual data items. On the other hand, trust relationships often exist between users, allowing them to accept or reject other users' beliefs by default. As those trust relationships become complex, however, it becomes difficult to define and compute a consistent snapshot of the conflicting information. Previous solutions to a related problem, the update reconciliation problem, are dependent on the order in which the updates are processed and, therefore, do not guarantee a globally consistent snapshot. This paper proposes the first principled solution to the automatic conflict resolution problem in a community database. Our semantics is based on the certain tuples of all stable models of a logic program. While evaluating stable models in general is well known to be hard, even for very simple logic programs, we show that the conflict resolution problem admits a PTIME solution. To the best of our knowledge, ours is the first PTIME algorithm that allows conflict resolution in a principled way. We further discuss extensions to negative beliefs and prove that some of these extensions are hard. This work is done in the context of the BeliefDB project at the University of Washington, which focuses on the efficient management of conflicts in community databases.

Weighted graphs: A tool for studying the halting problem and time complexity in term rewriting systems and logic programming

A scheme for programmable logic array (PLA) decomposition that consists of one level of PLAs followed by a second level of simple two-input logic gates is presented. The propagation delay is therefore the sum of the delay through one level of PLA and one level of two-input gates. Since the delay through a two-input gate is significantly less than that through a PLA, the timing performance of the new scheme is generally superior to those of earlier PLA decomposition schemes. The sizes of the PLAs used depend on the choice of the two-input gates. An algorithm is presented that chooses the functionality of the gates such that the areas of the first-level PLAs are minimized, further improving performance. The new decomposition scheme was developed for the automatic programming of a programmable logic device (PLD) which had basically a three level architecture. The functional unit for such a PLD is described and the application of the algorithm to the programming of these functional units is discussed. Experimental results show that the new scheme significantly reduces the area over the single PLA implementation. >

Preface. About This Book. Part 1: Paradigms of Programming. Introduction. Logic Programming. Higher-Order Functions. Combinators. Turing Machines. Part 2: Visualization. Animated Algorithms. Function Iteration and Chaos. Fractional Brownian Motion. Uniform Polyhedra. The Stellated Icosahedra. Ray Tracing. Single-Image Stereograms. Appendixes. References. Index of Programs. Index. Preface. About This Book: Overview. About the Programs. Notation and Terminology. The Mathematica Programmer CD-ROM. The Mathematica Programmer WWW Archive. Colophon.Part 1: Paradigms of Programming: Introduction: Mathematica's Programming Language. Pattern Matching and Term Rewriting. Programming Styles. Program Organization. Logic Programming: The Ingredients of Logic Programs. A PROLOG Interpreter for Mathematica. Lists in PROLOG. Backtracking. Deduction. Higher-Order Functions: Introduction. The Functional Features of Mathematica. Functions as Data. Fixed Points of Higher-Order Functions. Combinators: Introduction. Combinatory Algebras. Combinatory Abstraction. Converting Functions to Combinators. Applications. Turing Machines: Introduction. A Turing Machine Simulator. Assembly Programming. Recursive Functions. Optimization. Conclusions. The Complete Code of TuringMacros.m. Part 2: Visualization: Animated Algorithms: Three Standard Sorting Algorithms. Asymptotic Behavior. Conclusions. Function Iteration and Chaos: Function Iteration. Bifurcations. The Final-State Diagram. The Ingredients of Chaos. Super-Attractive Orbits. Conclusions. Fractional Brownian Motion: Introduction. Random Additions. Fourier Synthesis. Random Faults. Analysis of fBm Data. Uniform Polyhedra: Introduction. Uniform Construction. Data Structures. Rendering. Auxiliary Programs. The Stellated Icosahedra: Introduction. Rendering. Discussion. The Complete Code of Icosahedra.m. Ray Tracing: A Data Type for Surfaces. Photorealistic Rendering. Converting Mathematica Graphics. Sample Images. Stereo Pairs. The Complete Code of POVray.m. Single-Image Stereograms: Introduction. The Classis SIRDS in Mathematica. Designing Good Images. Exact Stereograms. Interface to External SIS Generators. The Complete Code of SIS.m. Appendixes. References. Index of Programs. Index.

[Gelfond and Lifschitz, 1991] introduced simple disjunctive logic programs and defined the answer set semantics called GL-semantics. We observed that the requirement of GL-semantics, i.e., an answer set should be a minimal model of the GL-reduct may be too strong and exclude some answer sets that would be reasonably acceptable. To address this, we present a novel and more permissive semantics, called determining inference semantics.

Facing a staggering diversity of software behaviours in modern and future computing, we argue for the need of a unified theory of program logics for a wide variety of software behaviours as a foundation of software engineering.We propose Hennessy-Milner logic for typed π-calculi as one possible such foundation. The π-calculus enjoys a singular position among computational calculi through its ability to embed sequential and concurrent programs as name passing processes without losing semantic information, and through its connection to other basic theories such as Linear Logic and Game Semantics. The embedding of programs in processes leads to the embedding of logics for programs in the logic for processes, where the observational content of a given program logic is made explicit, analysed and justified on a uniform basis. As a case study, we show embeddings of Hoare logic for sequential programs and a rely-guarantee logic for shared variable concurrency, suggesting that the proposed framework can offer a unifying basis to capture fundamental notions in program logics such as partial/total correctness, sequentiality and different kinds of concurrent computing.