Some natural structures which fail to possess a sound and decidable hoare-like logic for their while-programs

In this paper we discuss the semantics of a simple block-structured programming language which allows sharing or aliasing. Sharing, which arises naturally in procedural languages which permit certain forms of parameter passing, has typically been regarded as problematical for the semantic treatment of a language. Difficulties have been encountered in both denotational and axiomatic treatments of sharing in the literature. Nevertheless, we find that it is possible to define a clean and elegant formal semantics for sharing. The key to our success is the choice of semantic model; we show that conventional approaches based on locations are less than satisfactory for the purposes of reasoning about partial correctness, and that in a well defined sense locations are unnecessary.We begin by defining a denotational semantics for our programming language. The semantic model is not based on locations, but instead uses an abstract sharing relation on identifiers to represent the notion of aliasing, and uses an abstract state with a stack-like structure to capture the semantics of blocks and accurately model the scope rules. The semantics is shown to be fully abstract with respect to partial correctness properties, in contrast to conventional location-based models. This means that the semantics identifies terms if and only if they induce identical partial correctness behaviour in all program contexts. This property usually fails for location-based semantics because in such models it is possible to distinguish between terms on the basis of their effect on individual locations, which has no bearing on partial correctness.We believe that axiomatic reasoning about program behaviour should be based directly on a semantic model specifically tailored for that purpose; full abstraction with respect to an appropriate behavioural notion is a formal criterion against which to judge the suitability of a semantics. The structure of a semantic model should be used directly to suggest the structure of an assertion language for expressing program properties. With this in mind, we build a Hoare-style (syntax-directed) proof system for partial correctness properties of our programming language, and we prove soundness and relative completeness of this system. The proof system is built up in a hierarchical manner which reflects the syntactic and semantic structure of the programming language. We first design a proof system for declarations, and then use it in building proof rules for commands. We claim that our proof rules are conceptually simpler to understand than other rules proposed in the literature for aliasing, without losing any expressive power. We show, for example, that it is possible to define a “generic” inference rule for blocks which is uniformly applicable to3 blocks headed by different forms of declaration. The important point here is that, unlike most of the proof systems for these constructs in the literature, we do not have to design a separate rule for blocks for each possible form of declaration. This results in greater flexibility and adaptability in our proof system. We demonstrate that some well known rules from the literature for blocks can be derived in our system.

We formalize a Hoare logic for the partial correctness of while programs in PVS and prove its soundness and relative completeness. We use the PVS higher-order logic to define the syntax and semantics of a small imperative programming language, and describe a proof system for Hoare triples involving programs in this language. We prove the soundness of the proof system by demonstrating that only valid triples are provable. We also demonstrate the relative completeness of the proof system by defining the weakest liberal precondition operator and using it to prove that all valid Hoare triples are provable modulo the assertion logic. Finally, we verify a verification condition generator for Hoare logic Variants of Hoare logic have been formalized before in PVS and using other interactive proof assistants. We use Hoare logic as a tutorial exercise to illustrate the effective use of PVS in capturing the syntax and semantics of embedded logics. The embedding of Hoare logic is simple enough to be easily reproduced by the reader, but it also illustrates some of the nuances of formalization and proof using PVS, in particular, and higher-order logic, in general.

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.

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.

For a wide class of programming languages P and expressive interpretations I, we show that there exist sound and relatively complete Hoare-like logics for both partial correctness and termination assertions. In fact, under mild assumptions on P and I, we show that the assertions true for P in I are uniformly decidable in the theory of I (Th(I)) iff the halting problem for P is decidable for finite interpretations. Moreover termination assertions are uniformly r.e. in Th(I) even if the halting problem for P is not decidable for finite interpretations. Since total correctness assertions coincide with termination assertions for deterministic programming languages, this last result unexpectedly suggests that the class of languages with good axiom systems for total correctness may be wider than for partial correctness.

We present an extension of type theory with a fixed point combinator Y. We are particularly interested in using this Y for doing unbounded proof search in the proof system. Therefore we treat in some detail a typed λ-calculus for higher order predicate logic with inductive types (a reasonable subsystem of the theory implemented in [Dowek e.a. 1991]) and show how bounded proof search can be done in this system, and how unbounded proof search can be done if we add Y. Of course, proof search can also be implemented (as a tactic) in the meta language. This may give faster results, but asks from the user to be able to program the implementation. In our approach the user works completely in the proof system itself. We also provide the meta theory of type theory with Y that allows to use the fixed point combinator in a safe way. Most importantly, we prove a kind of conservativity result, showing that, if we can generate a proof term M of formula Τ in the extended system, and M does not contain Y , then M is already a proof of Τ in the original system.

In this paper, we investigate the theoretical foundation for the cost/precision trade-off of data flow graphs for verification. We show that one can use the theory of tree automata in order to characterize the loss of precision inherent in the abstraction of a program by a data flow graph. We also show that one can transfer a result of Oh et al. and characterize the power of the proof system of data flow proofs (through a restriction on the assertion language in Floyd-Hoare proofs).

We study a programming language with a built-in ground type for real numbers. In order for the language to be sufficiently expressive but still sequential, we consider a construction proposed by Boehm and Cartwright. The non-deterministic nature of the construction suggests the use of powerdomains in order to obtain a denotational semantics for the language. We show that the construction cannot be modelled by the Plotkin or Smyth powerdomains, but that the Hoare powerdomain gives a computationally adequate semantics. As is well known, Hoare semantics can be used in order to establish partial correctness only. Since computations on the reals are infinite, one cannot decompose total correctness into the conjunction of partial correctness and termination as it is traditionally done. We instead introduce a suitable operational notion of strong convergence and show that total correctness can be proved by establishing partial correctness (using denotational methods) and strong convergence (using operational methods). We illustrate the technique with a representative example.

The principles of computer skills have been included in primary and secondary educated since the early 2000s, and the reform of curricula is related to the development of IT. Therefore, curricula should reflect the latest technological trends and needs of society. The development of a curriculum involves the subjective judgment of a few experts or professors to extract knowledge from several similar documents. More objective extraction needs to be based on standardized terminology, and professional terminology can help build content frames for organizing curricula. The purpose of this study is to develop a smart system for extracting terms from the body of computer science (CS) knowledge and organizing knowledge areas. The extracted terms are composed of semantically similar knowledge areas, using the word2vec model. We analyzed a higher-education CS standards document and compiled a dictionary of technical terms with a hierarchical clustering structure. Based on the developed terminology dictionary, a specialized system is proposed to enhance the efficiency and objectivity of terminology extraction. The analysis of high school education courses in India and Israel using the technical term extraction system found that (1) technical terms for Software Development Fundamentals were extracted at a high rate in entry-level courses, (2) in advanced courses, the ratio of technical terms in the areas of Architecture and Organization, Programming Languages, and Software Engineering areas was high, and (3) electives that deal with advanced content had a high percentage of technical terms related to information systems.

Numerous businesses and institutions are involved in the study, design, manufacture, and sale of automobiles; they are all part of the Automotive Sector. In terms of market capitalization, the automobile industry is among the top five most profitable in the world. Businesses in the car business and those closely related to it are the ones who really get to put wheels on the road. Most of the parts are included in this, including the engine and body, but not the wheels, batteries, or gas. The automotive industry has worldwide influence and significance notwithstanding the problem of excess capacity and poor profitability. The automotive industry is vital to global trade and production. More than half of the world's oil consumption is attributable to the production of about 60 million automobiles and light trucks annually. Self-driving capabilities, in-car Wi-Fi and navigation systems, parking assistance, programmable computers, energy- saving features, night-vision aid, all-around cameras, automatic emergency braking, sensors to detect pedestrians, and driver concentration aids, etc. are just a few of the technologies we use often in our cars. Several features in cars that we use often include autonomous driving capabilities, in-car internet, parking assistance, onboard computers, and parking sensors. Our ride is safe and comfortable because of these features. Automobiles rely on the driver's active participation to function properly. Although, "how can we achieve this, and what is the logic behind the automobile industry?" is the fundamental issue that has to be posed. Computer jargon or programming language may be a good way to describe the answer to this issue. Incorporating new languages into vehicles is now possible because of the abundance of available programming languages. The Automotive Group relies heavily on machine learning and AI to accomplish its goals. Keywords— Artificial Intelligence, Automotive Industry, Deep Learning, Convolutional Neural Network, Technology, Machine Learning

This is part of the Turing-inspired Meta-Morphogenesis project, which aims to identify transitions in information-processing since the earliest proto-organisms, in order to provide new understanding of varieties of biological intelligence, including the mathematical intelligence that produced Euclid’s Elements. (Explaining evolution of mathematicians is much harder than explaining evolution of consciousness!) Transitions depend on “construction kits”, including the initial “Fundamental Construction Kit” (FCK) based on physics and Derived Construction Kits (DCKs) produced by evolution, development, learning and culture. Some construction kits (e.g. Lego, Meccano, plasticine, sand) are concrete using physical components and relationships. Others (e.g. grammars, proof systems and programming languages) are abstract, producing abstract entities, e.g. sentences, proofs, and new abstract construction kits. Mixtures of the two are hybrid kits. Some are meta-construction kits able to create, modify or combine construction kits. Construction kits are generative: they explain sets of possible construction processes, and possible products, with mathematical properties and limitations that are mathematical consequences of properties of the kit and its environment. Evolution and development both make new construction kits possible. Study of the FCK and DCKs can lead us to new answers to old questions, e.g. about the nature of mathematics, language, mind, science, and life, exposing deep connections between science and metaphysics. Showing how the FCK makes its derivatives, including all the processes and products of natural selection, possible is a challenge for science and philosophy. This is a long-term research programme with a good chance of being progressive in the sense of Lakatos. Later, this may explain how to overcome serious current limitations of AI (artificial intelligence), robotics, neuroscience and psychology.

CL (Clausal Language) is a computer programming language with mathematical syntax and a proof system based on Peano arithmetic which we have repeatedly used in the teaching of three (first and second year) undergraduate courses covering respectively declarative programming, program verification, and program and abstract data specification.

The author studies the higher-order rewrite/equational proof systems obtained by adding the simply typed lambda calculus to algebraic rewrite/equational proof systems. He shows that if a many-sorted algebraic rewrite system has the Church-Rosser property, then the corresponding higher-order rewrite system which adds simply typed beta -reduction has the Church-Rossers property too. This result is relevant to parallel implementations of functional programming languages. The author also shows that provability in the higher-order equational proof system obtained by adding the simply typed beta and eta axions to some many-sorted algebraic proof system is effectively reducible to provability in that algebraic proof system. This effective reduction also establishes transformations between higher-order and algebraic equational proofs, which can be useful in automated deduction.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Verification of object-oriented programs: A transformational approach

Separation logic (SL) is a logical formalism for reasoning about programs that use pointers to mutate data structures. It is successful for program verification as an assertion language to state properties about memory heaps using Hoare triples. Most of the proof systems and verification tools for ${\textrm{SL}}$ focus on the decidable but rather restricted symbolic heaps fragment. Moreover, recent proof systems that go beyond symbolic heaps are purely syntactic or labelled systems dedicated to some fragments of ${\textrm{SL}}$ and they mainly allow either the full set of connectives, or the definition of arbitrary inductive predicates, but not both. In this work, we present a labelled proof system, called ${\textrm{G}_{\textrm{SL}}}$, that allows both the definition of cyclic proofs with arbitrary inductive predicates and the full set of SL connectives. We prove its soundness and show that we can derive in ${\textrm{G}_{\textrm{SL}}}$ the built-in rules for data structures of another non-cyclic labelled proof system and also that ${\textrm{G}_{\textrm{SL}}}$ is strictly more powerful than that system.