Showing papers on "Program analysis published in 1973"
1 Oct 1973
TL;DR: A theorem prover that embodies knowledge about programming constructs, such as numbers, arrays, lists, and expressions, that can reason about these concepts and is used as part of a program verification system that uses the Floyd-Naur explication of program semantics.
Abstract: This paper describes a theorem prover that embodies knowledge about programming constructs, such as numbers, arrays, lists, and expressions. The program can reason about these concepts and is used as part of a program verification system that uses the Floyd-Naur explication of program semantics. It is implemented in the QA4 language; the QA4 system allows many bits of strategic knowledge, each expressed as a small program, to be coordinated so that a program stands forward when it is relevant to the problem at hand. The language allows clear, concise representation of this sort of knowledge. The QA4 system also has special facilities for dealing with commutative functions, ordering relations, and equivalence relations; these features are heavily used in this deductive system. The program interrogates the user and asks his advice in the course of a proof. Verifications have been found for Hoare's FIND program, a real-number division algorithm, and some sort programs, as well as for many simpler algorithms. Additional theorems have been proved about a pattern matcher and a version of Robinson's unification algorithm.
39 citations
TL;DR: The proposed documentation procedure is designed to help the engineer who is to use the computer program, the programmer who may have to modify it, and the computer operator who must run it.
Abstract: This paper presents a proposed standard for documenting engineering computer programs. The need for good program documentation and for a standard procedure to prepare such documentation is discussed. The proposed documentation procedure is designed to help the engineer who is to use the computer program, the programmer who may have to modify it, and the computer operator who must run it. The recommendations are illustrated by a completely documented sample computer program.
3 citations
1 Jun 1973
TL;DR: A mechanism for holding a program in syntactic form that can be useful to any program which processes programs: in program verification automatic programming, and specialized text editing.
Abstract: : The paper describes a mechanism for holding a program in syntactic form. This mechanism can be useful to any program which processes programs: in program verification automatic programming, and specialized text editing. In this case the program holder is used to form the basis for syntax-driven text editor. Formal specifications for the program holder are also given. (Author)
2 citations
[...]
TL;DR: There is no question that reliability is an important factor in the production and life cycle of software, and while operating systems may be too large to prove correct, there are often key algorithms and critical properties which are good candidates.
Abstract: There is no question that reliability is an important factor in the production and life cycle of software. Logical correctness is the first step towards achieving reliability. While operating systems may be too large to prove correct, in view of the current state of the art, there are often key algorithms and critical properties which are good candidates.A precise statement of the properties, assumptions, and theorems involved greatly influences the reliability of the program. As a side benefit we get a tremendous understanding of the operation of the programs while trying to prove their correctness. By the time we have stated formally all the properties, assertions and theorems involved, the program is sufficiently analyzed informally to ensure its correctness for all practical purposes.
1 citations
1 Jan 1973
TL;DR: In this paper, an approach to control extensibility applicable on the source language level to appropriate programming languages is presented, using the recursive language LISP as an example, extensions are defined that provide call by name function parameters, generator functions (as in IPL-V), nondeterministic functions, and general coroutines.
Abstract: Techniques for language extension are of interest today as a means for language design experimentation without language proliferation. Attention thus far has been focused on methods for data structure definition and manipulation. The problem of program control extensibility has been recognized by workers in the field but less thoroughly treated. This paper outlines an approach to control extensibility applicable on the source language level to appropriate programming languages. Using the recursive language LISP as an example, extensions are defined that provide call by name function parameters, generator functions (as in IPL-V), nondeterministic functions, and general coroutines. LISP facilitates this exercise by features including dynamic scope of variables, source programs manipulatable as data, simplicity of program state representations, and control over context of function evaluation. The results of this paper suggest criteria for evaluating base languages in extensible programming systems, as well as a possible insight into formal program analysis.
IBM1
TL;DR: A medium being developed for abstraction and expression of program structure is described, to be used to represent programs during the design process and forms the basis for their implementation.
Abstract: This paper describes a medium being developed for abstraction and expression of program structure. The medium is to be used to represent programs during the design process; It forms the basis for their implementation.The following point of view is adopted. Program design is an iterative, trial-and-error process, in which a basic solution to part of the problem is refined, added to, and modified into a complete solution. The final result should be well-structured in the sense described by Dijkstra (1) in order for the designer to understand the program sufficiently to be confident in its correctness.
1 Dec 1973
TL;DR: This computer program manual describes in two parts the automated combustor design optimization code AUTOCOM, written in the FORTRAN 4 language.
Abstract: This computer program manual describes in two parts the automated combustor design optimization code AUTOCOM. The program code is written in the FORTRAN 4 language. The input data setup and the program outputs are described, and a sample engine case is discussed. The program structure and programming techniques are also described, along with AUTOCOM program analysis.
1 Jan 1973
TL;DR: In this paper, symbolic logic is applied to program analysis and program synthesis, where the correctness and equivalence problems can be formulated as a termination problem, and logical consequences serve as a basis to describe the input-output relationship.
Abstract: Publisher Summary
This chapter presents the application of symbolic logic to program analysis and program synthesis. By program analysis, it is meant that a program is given and one wants to know the input-output relationship of the program. As for program synthesis, one is given an input-output relationship and wants to synthesize a program to realize this input-output relationship. The correctness and equivalence problems can actually be formulated as a termination problem. One can use logical formulas to describe the execution of a program. Considering these formulas as axioms, one can deduce logical consequences from these axioms. Some logical consequences serve as a basis to describe the input-output relationship. In particular, there is one clause, called the halting clause, that will be mechanically deduced, using the resolution principle, if and only if the program terminates. This clause not only tells that the program terminates, but also tells how it terminates. Thus, using this halting clause, one can see whether the program meets the specification, or is equivalent to some other program.
Proceedings Article•
1 Mar 1973TL;DR: Various heuristic techniques for use in proving the correctness of computer programs are presented, designed to obtain automatically the "inductive assertions" attached to the loops of the program which previously required human "understanding" of the programs' performance.
Abstract: We present various heuristic techniques for use in proving the correctness of computer programs. The techniques are designed to obtain automatically the "inductive assertions" attached to the loops of the program which previously required human "understanding" of the program''s performance. We distinguish between two general approaches: one in which we obtain the inductive assertion by analyzing predicates which are known to be true at the entrances and exits of the loop ($underline{top-down}$ approach), and another in which we generate the inductive assertion directly from the statements of the loop ($underline{bottom-up}$ approach).