Showing papers on "Operational semantics published in 1981"

Denotational Semantics: The Scott-Strachey Approach to Programming Language Theory

Abstract: From the Publisher: "First book-length exposition of the denotational (or `mathematical' or `functional') approach to the formal semantics of programming languages (in contrast to `operational' and `axiomatic' approaches) Treats various kinds of languages, beginning with the pure-lambda-calculus and progressing through languages with states, commands, jumps, and assignments This somewhat discursive account is a valuable compilation of results not otherwise available in a single source" -- American Mathematical Monthly

Algebraic Semantics

Abstract: But here, you can get it easily this algebraic semantics to read. As known, when you read a book, one to remember is not only the PDF, but also the genre of the book. You will see from the PDF that your book chosen is absolutely right. The proper book option will influence how you read the book finished or not. However, we are sure that everybody right here to seek for this book is a very fan of this kind of book.

Foundations of Actor Semantics

Abstract: The actor message-passing model of concurrent computation has inspired new ideas in the areas of knowledge-based systems, programming languages and their semantics, and computer systems architecture. This thesis extends and unifies the work of Carl Hewitt, Irene Greif, Henry Baker, and Giuseppe Attardi, who developed the mathematical content of the model. The ordering laws postulated by Hewitt and Baker can be proved using a notion of global time. The most general ordering laws are equivalent to an axiom of realizability in global time. Since nondeterministic concurrency is more fundamental than deterministic sequential computation, there may be no need to take fixed points in the underlying domain of a power domain. Power domains built from incomplete domains can solve the problem of providing a fixed point semantics for a class of nondeterministic programming languages in which a fair merge can be written. The locality laws postulated by Hewitt and Baker may be proved for the semantics of an actor-based language. Altering the semantics slightly can falsify the locality laws. The locality laws thus constrain what counts as an actor semantics.

Formal Semantics for Time in Databases.

Abstract: The concept of a historical database is introduced as a tool for modeling the dynamic nature of some part of the real world. Just as first-order logic has been shown to be a useful formalism for expressing and understanding the underlying semantics of the relational database model, intensional logic is presented as an analogous formalism for expressing and understanding the temporal semantics involved in a historical database. The various components of the relational model, as extended to include historical relations, are discussed in terms of the model theory for the logic ILs, a variation of the logic IL formulated by Richard Montague. The modal concepts of intensional and extensional data constraints and queries are introduced and contrasted. Finally, the potential application of these ideas to the problem of natural language database querying is discussed.

Ordering semantics and premise semantics for counterfactuals

Abstract: 1. COUNTERFACTUALS AND FACTUAL BACKGROUND Consider the counterfactual conditional 'If I were to look in my pocket for a penny, I would find one'. Is it true? That depends on the factual background against which it is evaluated. Perhaps I have a penny in my pocket. Its presence is then part of the factual background. So among the possible worlds where I look for a penny, those where there is no penny may be ignored as gratuitously unlike the actual world. (So may those where there is only a hidden penny; in fact my pocket is uncluttered and affords no hiding place. So may those where I'm unable to find a penny that's there and unbidden.) Factual background carries over into the hypothetical situation, so long as there is nothing to keep it out. So in this case the counterfactual is true. But perhaps I have no penny. In that case, the absence of a penny is part of the factual background that carries over into the hypothetical situation, so the counterfactual is false. Any formal analysis giving truth conditions for counterfactuals must somehow take account of the impact of factual background. Two very natural devices to serve that purpose are orderings of worlds and sets of premises. Ordering semantics for counterfactuals is presented, in various versions, in Stalnaker [8], Lewis [5], and Pollock [7]. (In this paper, I shall not discuss Pollock's other writings on counterfactuals.) Premise semantics is presented in Kraker [3] and [4]. (The formally parallel theory of Veltman [l 11 is not meant as truthconditional semantics, and hence falls outside the scope of this discussion.) I shall show that premise semantics is equivalent to the most general version - roughly, Pollock's version - of ordering semantics. I should like to postpone consideration of the complications and disputes that arise because the possible worlds are infinite in number. Let us therefore pretend, until further notice, that there are only finitely many worlds. That pretence will permit simple and intuitive formulations of the theories under consideration.

Formal semantics of programming languages: VDL

Abstract: The history of ideas that led to the first formalization of the syntax and semantics of PL/I is sketched. The definition method and notation are known as the Vienna Definition Language (VDL). The paper examines the relationship between VDL and both denotational semantics and the axiomatic approach to programming language definition.

Procedural Semantics as a Theory of Meaning.

Abstract: : This report addresses fundamental issues of semantics for computational systems. The question at issue is 'What is it that machines can have that would correspond to the knowledge of meanings that people have and that we seem to refer to by the ordinary language term 'meaning'?' The proposed answer is that the notion of truth-conditions can be explicated and made precise by identifying them with a particular kind of abstract procedure and that such procedures can serve as the meaning bearing elements of a theory of semantics suitable for computer implementation. This theory, referred to as 'procedural semantics', has been the basis of several successful computerized systems and is acquiring increasing interest among philosophers of language. (Author)

An Operational Semantics for Pure Dataflow

Abstract: In this paper we prove the equivalence of an operational and a denotational semantics for pure dataflow. The term pure dataflow refers to dataflow nets in which the nodes are functional (i.e. the output history is a function of the input history only) and the arcs are unbounded fifo queues. Gilles Kahn gave a method for the representation of a pure dataflow net as a set of equations; one equation for each arc in the net. Kahn stated, and we prove, that the operational behaviour of a pure dataflow net is exactly described by the least fixed point solution to the net's associated set of equations.

Algebraic Denotational Semantics Using Parameterized Abstract Modules

Abstract: This paper describes a method for giving structured algebraic denotational definitions of programming language semantics. The basic idea is to use parameterized abstract data types to construct a directed acyclic graph of modules, such that each module corresponds to some feature of the language. A "feature" in this sense is sometimes a syntactic construction, and is sometimes a more basic language design decision. Our definitions are written in the executable algebraic specification language OBJT. Among the advantages of our approach are the following: it is relatively easier to understand the definitions because they are organized into modules and use flexible user-definable syntax; it is also relatively easy to modify or to extend the definitions, not only because of the modularity, but also because of the use of parameterization; it is possible to debug the definitions by executing test cases, which in this case are programs; the definitions are relatively compact; and they impose relatively little implementation bias. This paper illustrates these points with the definition of a modest programming language with integer and boolean expressions, blocks, iteration, conditional, input and output, and side-effect-only procedures, which can be assigned to variables and passed as parameters.

Goto statements: semantics and deduction systems

Abstract: A simple language containing goto statements is presented, together with a denotational and operational semantic for it. Equivalence of these semantical descriptions is proven. Furthermore, soundness and completeness of a Hoare-like proof system for the language is shown. This is done in two steps. Firstly, a proof system is given and validity is defined using (a variant of) direct semantics. In this case soundness and completeness proofs are relatively easy. After that, a proof system is given which is more in the style of the one by Clint and Hoare [8], and validity in this system is defined using continuation semantics. This validity definition is then related to validity in the first system and, using this correspondence, soundness and completeness for the second system is proven.

Specifying the Semantics of while Programs: A Tutorial and Critique of a Paper by Hoare and Lauer

Abstract: : Three kinds of mathematical objects are considered which can be designated as the 'meaning or 'semantics' of programs: binary relations between initial and final states, binary relations on predicates (partial correctness semantics), and functionals from predicates to predicates (predicate transformers). We exhibit various formal specification mechanisms: induction on program syntax, axioms, and deductive systems. We show that each kind of semantics can be specified by several different mechanisms. As long as arbitrary predicates on states are permitted, each kind of semantics uniquely determines the others -- with the sole exception of the weakest pre-condition semantics for nondeterministic programs.

Correctness of Programs with Function Procedures

Abstract: The correctness of programs with programmer-declared functions is investigated. We use the framework of the typed lambda calculus with explicit declaration of (possibly recursive) functions. Its expressions occur in the statements of a simple language with assignment, composition and conditionals. A denotational and an operational semantics for this language are provided, and their equivalence is proved. Next, a proof system for partial correctness is presented, and its soundness is shown. Completeness is then established for the case that only call-by-value is allowed. Allowing call-by-name as well, completeness is shown only for the case that the type structure is restricted, and at the cost of extending the language of the proof system. The completeness problem for the general case remains open. In the technical considerations, an important role is played by a reduction system which essentially allows us to reduce expression evaluation to systematic execution of auxiliary assignments. Termination of this reduction system is shown using Tait's computability technique. Complete proofs will appear in the full version of the paper.

Program verification based on denotation semantics

Abstract: A theory of partial correctness proofs is formulated in Scott's logic computable junctions. This theory allows mechanical construction of verification condition solely on the basis of a denotational language definition. Extensionally these conditions, the resulting proofs, and the required program augmentation are similar to those of Hoare style proofs; conventional input, output, and invariant assertions in a first order assertion language are required. The theory applies to almost any sequential language defined by a continuation semantics; for example, there are no restrictions on aliasing or side-effects. Aspects of "static semantics",such as type and declaration constraints, which are expressed in the denotational definition are validated as part of the verification condition generation process.

Abstract Data Types and Rewriting Systems: Application to the Programming of Algebraic Abstract Data Types in Prolog

Abstract: The aim of the paper is to present the operational semantics of Algebraic Abstract Data Types (AAT) in terms of rewriting systems and their programming in PROLOG respectively.

Conditions on Rules: The Proper Balance Between Syntax and Semantics

Abstract: Excellent book is always being the best friend for spending little time in your office, night time, bus, and everywhere. It will be a good way to just look, open, and read the book while in that time. As known, experience and skill don't always come with the much money to acquire them. Reading this book with the PDF conditions on rules the proper balance between syntax and semantics will let you know more things.

Formal Semantics and the Existence of Sets

Abstract: Nearly everyone who has any belief at all in the matter thinks that if one adopts a "set-theoretical" interpretation for a formal theory, one thereby becomes committed to the existence of (certain) sets. The main purpose of this paper is to argue that this belief is false. It seems to me that its falsity follows from a few surprisingly straightforward points about the semantics of formal theories. If this is correct, it may be of methodological interest to those who are suspicious about the existence of sets. They may needlessly have deprived themselves of the use of set-theoretical semantics. A second goal of this paper is to show how a certain problem about pure set theory can be solved by applying the considerations raised in the first part of the paper. I call this the problem of a "realistic" interpretation of set theory. This is more likely to be of interest to those who have no doubts about the existence of sets. The first part of the paper presupposes only a basic familiarity with (countable) first-order languages and theories, and with (some) one of the usual set-theoretical (or: "model-theoretical") notions of interpretation for these systems. In particular, I treat interpretations as ordered sets whose first members are non-empty sets, called "domains of interpretation," and whose other members are correlated with whatever non-logical symbols may be present in the language (and are themselves closely related to the domain of interpretation). Such ordered sets are perhaps most elegantly viewed as functions whose domains are small countable ordinals, where functions are in turn viewed as sets of ordered pairs, and ordered pairs are regarded systematically as certain "unordered" sets. But such details are unimportant beyond the central fact that in the end an interpretation of a first-order language simply is a more or less complicated set one of whose "ingredients" is a domain of interpretation for the quantifiers of the language. The second part of the paper presupposes a rudimentary acquaintance with Zermelo-Fraenkel set theory (ZF). I assume in both parts of the paper that ZF is consistent.

The formal definition of a real-time language

Abstract: This paper presents the formal definition of TOMAL (Task-Oriented Microprocessor Applications Language), a programming language intended for real-time systems running on small processors. The formal definition addresses all aspects of the language. Because some modes of semantic definition seem particularly well-suited to certain aspects of a language, and not as suitable for others, the formal definition employs several complementary modes of definition. The primary definition is axiomatic and is employed to define most statements of the language. Simple, denotational (but not lattice-theoretic) semantics complement the axiomatic semantics to define type-related features, such as binding of names to types, data type coercions, and evaluation of expressions. Together, the axiomatic and denotational semantics define all features of the sequential language. An operational definition is used to define real-time execution, and to extend the axiomatic definition to account for all aspects of concurrent execution. Semantic constraints, sufficient to guarantee conformity of a program with the axiomatic definition, can be checked by analysis of a TOMAL program at compilation.

In Scott-Strachey style denotational semantics, parallelism implies nondeterminism

Abstract: A minimum algebraic structure needed in Scott-Strachey style denotational semantics for parallel programs is developed. Some elementary algebra shows that nondeterministic semantics is inherently and uniquely present. Conversely, any simple nondeterministic semantics provides uniquely a semantics for a minimal parallel computation capability.

Essential formal semantics

Abstract: The solution to get this book is that we don't over you the free book. But, we offer you the free information about essential formal semantics. Why should be this book to read and where is the place to get it, even the soft file forms are common questions to utter. In this website, we don't only provide this book. We have still lots of books to read. Yeah, we are on-line library that is always full of recommended books.