Denotational Definition Research Articles

“The Very Hydra of the Time”: Morton’s New English Canaan and Atlantic Trade

On May 1, 1627, Thomas and the inhabitants of Mount--formerly Mount Wollaston and even more formerly Passonagessit--raised their infamous maypole, which in turn raised the ire of the precise at Plimouth. This maypole has become one of the most enduring icons of early British settlement in Massachusetts, trailing perhaps only the cornucopia that has come symbolize Plymouth-inspired Thanksgiving tradition, but in its day the Mar-re Mount maypole was for the Plymouth Separatists tangible symbol of the well-lubricated gaiety that accompanied the celebrations linking the Anglican Church with Britannia's pagan past. Bostonian Puritans likewise disapproved of these pagan significances, but also saw in the maypole reminder of the aristocratic hierarchy that sanctioned and lorded over the May Day bacchanal--a view that prompted John Endicott, during Morton's first brief exile, chop down the maypole and rebuke those still living at For later historians of Massachusetts, Morton's maypole continued justify an interpretation of Mount as place of drunken licentiousness, pseudoanarchical foil the rigid Puritanism of Plymouth and Boston. Likewise New English Canaan, Thomas Morton's account of Mare was relegated the status of second-class counterhistory William Bradford's Of Plymouth Plantation. (1) Fiction writers from Lydia Marie Child Robert Lowell have similarly focused on the jollity represented by Morton's maypole, for good or ill, as John McWilliams traces in his article, Fictions of Mount. Much like the gold coin nailed the Pequod's mast in Moby-Dick, the maypole of Mount reflects the mind of the observer, unlimited in its significations. semiotic flexibility of Morton's maypole indicative of the wider trouble New English Canaan has posed the two-pronged view of British colonization in North America, wherein religious Pilgrims dominated New England while Virginian settlements were focused on more secular economic interests. (2) and his plantation have seemingly always been problematic reality for the dominant narrative of Anglo-American colonization. Even his plantation's name, has engendered interpretive controversy. Though never in New English Canaan calls his rechristening of Mount Wollaston anything other than Ma-re Mount, the name has come down through popular history as Merry Mount, originally pejorative applied by Bradford and solidified in the American mythos through Nathaniel Hawthorne's short story The MayPole of Mount. As Karen Kupperman points out, the Puritan influence on American history is again seen in the fact that their construction, Merrymount, stuck (662). And while surely knew of the possibilities for punning on the name--he does joke that the Separatists threatened to make it woeful and not merry mount (136)--he consistently resists applying the lighthearted appellation himself. As this homonymic struggle indicates, much like the maypole itself, the settlement's name presents readers with a compound title of almost unlimited suggestibility'--one that evokes interpretations ranging from description of physical location bestiality (McWilliams 7). But amid the myriad possibilities, perhaps the most basic denotational definition offers the best insight into the rhetorical implications of the settlement's name. In 1892 C. E Adams maintained that Mount was evidence of Morton's playful linguistic Latinity, meaning, as McWilliams notes, Morton had in mind the ablative of mare and the name meant 'the hill by the sea' (6). (3) In thus naming his settlement seems point out its ties the Atlantic; and indeed, many of the attributes for which Mount became infamous have distinct ties the maritime world. Most critical historical and literary studies of Mount and New English Canaan dwell on Morton's connection the American interior, usually focusing on his advantageous trade and social relationships with American Indians. …

Conformance notions for the coordination of interaction components

In component-based development, software components are taken as units of composition. Nevertheless, to achieve the widely disseminated status of components being plugged together as simple ‘Lego Pieces’, the integration of components must be carefully designed, systematised and verified; only this can ensure reliable architectures. In this work, we propose some conformance notions to predict the precise nature of some forms of composition, considering coordination patterns used in the integration. These notions are formalised in terms of the denotational semantics of the process algebra CSP, and assist the designer in common activities during integration, such as the substitution of component specifications by implementations, contract adaptations, and system extensions. To support mechanical verifications using FDR (a model-checker for CSP), we derive test characterisations from the denotational definitions of conformance. We illustrate the application of these notions through a systematic composition strategy of software frameworks, and we mechanically verify the preservation of behavioural component properties in these compositions. Moreover, we characterise the well-formedness of a coordination pattern used in this strategy at the design stage, before components are assembled.

Compositionality of Model Transformations

Model transformations can be used not only for code or platform-specific model generation, but also for denotational semantics definition, e.g. using process algebras as semantics for visual modeling languages. Denotational semantics of programming languages are by definition compositional. In order to enjoy a similar property in the case of model transformations, every component of the source model should be distinguishable in the target model and the mapping compatible with syntactic and semantic composition. Since typed graphs are a natural representation of visual models, model transformations are often described by typed graph transformations. This paper proposes a formal definition of compositionality for mappings from typed graphs to semantic domains. To verify compositionality, syntactic criterion has been established for the implementation of the mappings by graph transformations with negative application conditions. An example compositional transformation is presented that maps architectural models described in UML component diagrams to CSP.

Existential bare plurals: From properties back to entities

Post-carlsonian analyses of existential bare plurals have basically followed three lines of investigation, analyzing existential bare plurals as names of kinds, weak indefinites or properties. I show that none of the existing proposals can explain the behavior of bare plurals in Romance languages. I argue that we need to combine a revised version of Diesing's analysis of existential bare plurals with Steedman's analysis of indefinites and with Chierchia's neo-carlsonian analysis of kind-denoting bare plurals. The theoretical novelty of the paper is a denotational definition of Milsark's distinction between weak and strong indefinites. Both types of indefinites denote entities, which nevertheless differ regarding their domain: weak indefinites, and in particular existential bare plurals, refer to sums, which are derived entities that relate to each other by the part-whole relation, whereas strong indefinites refer to primitive entities that belong to an unordered set.

State-transition machines for lambda-calculus expressions

The process of compiler generation from lambda-calculus definitions is studied. The compiling schemes developed utilize as their object language the set of state transition machines (STMs): automata-like transition sets using first-order arguments. An intermediate definition form, the STM-interpreter, is treated as central to the formulation of STMs. Three compiling schemes are presented: one derived directly from an STM-interpreter for the lambda-calculus; one formulated from an STM-interpreter variant of Landin's SECD-machine; and one defined through meaning-preserving transformations upon a denotational definition of the lambda-calculus. The results are compared and some tentative conclusions are made regarding the utility of compiler generation with the STM forms.

A partial evaluator for a parallel lambda language

This paper describes theoretical and practical aspects of a partial evaluator that treats a parallel lambda language. The parallel language presented is a combination of lambda calculus and message passing communication mechanism. This parallel language can be used to write a programming language’s denotational semantics which extracts the parallelism in the program. From this denotational definition of the programming language, the partial evaluator can generate parallel compiler of the language by self-application. The key technique of partial evaluation is binding time analysis that determines in advance which parts of the source program can be evaluated during partial evaluation, and which parts cannot. A binding time analysis is described based upon type inference. A new typechcode is introduced into the type system, which denotes the type of those expressions containing residual channel operations. A well-formedness criterion is given which ensures that partial evaluation not only doesn’t commit type errors but also doesn’t change the sequence of channel operations. Before binding time analysis, channel analysis is used to analyze the communication relationship between send and receive processes.

A simple reflective interpreter

Procedurally reflective programming languages enable user programs to semantically extend the language itself, by permitting them to run at the level of the language implementation with access to their context. The reflective tower, first introduced by Brian Smith, is the principal architecture for such languages. It is informally described as an infinitely ascending tower of metacircular interpreters, connected by a mechanism that allows programs at one level to run at the next higher level. Various accounts of the reflective tower have been published, including a metacircular definition, operational definitions, and denotational definitions. We present an operational account of the main aspects of the reflective tower, which we claim is simpler than previous accounts. Our approach is to implement a finite tower where each level literally runs the level directly below it. A complete Scheme implementation is included.

LOGIC BASED PROGRAMMED STRUCTURE REWRITING SYSTEMS

This paper presents a new logic based framework for the formal treatment of graph rewriting systems as special cases of programmed rewriting systems for arbitrary relational structures. Considering its expressive power, the new formalism surpasses almost all variants of nonparallel algebraic as well as algorithmic graph grammar approaches by offering set-oriented pattern matching facilities as well as nonmonotonic reasoning capabilities for checking pre- and postconditions of rewrite rules. Furthermore, the formalism closes the gap between the operation-oriented manipulation of data structures by means of rewrite rules and the declaration-oriented description of data structures by means of logic based languages. Finally, the formalism even offers recursively defined (sub-)programs, by means of which the application of rewrite rules may be regulated. A denotational semantics definition for these (sub-)programs relies on a special variant of fixpoint theory for noncontinuous but monotonic functions.

Denotational semantics of a synchronous VHDL subset

A denotational definition for a single clock synchronous subset of VHDL is proposed. The different domains for variables and signals, the elaboration of static environments, and the formulation of a simulation algorithm for the sub-language characterize this definition, and distinguish it from more traditional denotational semantics of programming languages.

Denotational abstract interpretation of logic programs

Logic-programming languages are based on a principle of separation “logic” and “control.”. This means that they can be given simple model-theoretic semantics without regard to any particular execution mechanism (or proof procedure, viewing execution as theorem proving). Although the separation is desirable from a semantical point of view, it makes sound, efficient implementation of logic-programming languages difficult. The lack of “control information” in programs calls for complex data-flow analysis techniques to guide execution. Since data-flow analysis furthermore finds extensive use in error-finding and transformation tools, there is a need for a simple and powerful theory of data-flow analysis of logic programs. This paper offers such a theory, based on F. Nielson's extension of P. Cousot and R. Cousot's abstract interpretation . We present a denotational definition of the semantics of definite logic programs. This definition is of interest in its own right because of its compactness. Stepwise we develop the definition into a generic data-flow analysis that encompasses a large class of data-flow analyses based on the SLD execution model. We exemplify one instance of the definition by developing a provably correct groundness analysis to predict how variables may be bound to ground terms during execution. We also discuss implementation issues and related work.

Executing continuation semantics: A comparison

AbstractSeveral authors have suggested translating denotational semantics into prototype interpreters written in high‐level programming languages to provide evaluation tools for language designers. These implementations have generally been understandable when restricted to direct denotational semantics. This paper considers using two declarative programming languages, Prolog and Standard ML, to implement an interpreter that follows the continuation semantics of a small imperative programming language, called Gull. Each of the two declarative languages presents certain difficulties related to evaluation strategies and expressiveness. The implementations are compared in terms of their ease of use for prototyping, their resemblance to the denotational definitions, and their efficiency.

Non-determinism in Functional Languages

The introduction of a non-deterministic operator in even a very simple functional programming language gives rise to a plethora of semantic questions. These questions are not only concerned with the choice operator itself. A surprisingly large number of different parameter passing mechanisms are made possible by the introduction of bounded non-determinism. The diversity of semantic possibilities is examined systematically using denotational definitions based on mathematical structures called power domains

A domain-theoretic approach to functional and logic programming

AbstractThe integration of functional and logic programming languages has been a topic of great interest in the last decade. Many proposals have been made, yet none is completely satisfactory especially in the context of higher order functions and lazy evaluation. This paper addresses these shortcomings via a new approach: domain theory as a common basis for functional and logic programming. Our integrated language remains essentially within the functional paradigm. The logic programming capability is provided by set abstraction (via Zermelo-Frankel set notation), using the Herbrand universe as a set abstraction generator, but for efficiency reasons our proposed evaluation procedure treats this generator's enumeration parameter as a logical variable. The language is defined in terms of (computable) domain-theoretic constructions and primitives, using the lower (or angelic) powerdomain to model the set abstraction facility. The result is a simple, elegant and purely declarative language that successfully combines the most important features of both pure functional programming and pure Horn logic programming. Referential transparency with respect to the underlying mathematical model is maintained throughout. An implicitly correct operational semantics is obtained by direct execution of the denotational semantic definition, modified suitably to permit logical variables whenever the Herbrand universe is being generated within a set abstraction. Completeness of the operational semantics requires a form of parallel evaluation, rather than the more familiar left-most rule.

Correctness of static flow analysis in continuation semantics

We show how restructuring a denotational definition leads to a more efficient compiling algorithm. Two semantics-preserving transformations ( static replacement and factoring) are used to convert a continuation semantics into a formal description of a semantic analyzer and translator. The translation algorithm derived below performs type checking before code generation so that type-checking instructions may be omitted from the target code. The translation is proved correct with respect to the original definition of the source language. The proof consists of showing that both transformations preserve the semantics of the source language.

Formal verification of Ada programs

The Penelope verification editor and its formal basis are described. Penelope is a prototype system for the interactive development and verification of programs that are written in a rich subset of sequential Ada. Because it generates verification conditions incrementally, Penelope can be used to develop a program and its correctness proof in concert. If an already-verified program is modified, one can attempt to prove the modified version by replaying and modifying the original sequence of proof steps. Verification conditions are generated by predicate transformers whose logical soundness can be proven by establishing a precise formal connection between predicate transformation and denotational definitions in the style of continuation semantics. Penelope's specification language, Larch/Ada, belongs to the family of Larch interface languages. It scales up properly, in the sense that one can demonstrate the soundness of decomposing an implementation hierarchically and reasoning locally about the implementation of each node in the hierarchy. >

Two-level semantics and abstract interpretation

Two-level semantics is a variant of Scott/Strachey denotational semantics in which the concept of binding time is treated explicitly. This is done by formally distinguishing between those computations that take place at run-time and those that take place at compile-time. Abstract interpretation is concerned with the (preferably automatic) analysis of programs. The main purpose of these analyses is to find information that may assist in the efficient implementation of the programs. Abstract interpretation is thus related to data flow analysis, partial evaluation and other program analysis methods. Its unique flavour is the insistence on formal proofs of correctness and the methods used to establish these. This paper develops a theory of abstract interpretation for two-level denotational definitions. There are three ingredients in this. First a framework for proving the correctness of analyses is developed. This may also be used to compare the precision of various analyses. Next it is shown that, given a choice of properties of programs, one may specify a most precise analysis (or best induced analysis). This may also be used to investigate the collecting semantics (or static semantics). Finally, we show how to modify the most precise analysis in order to obtain an implementable analysis where we trade off precision for implementability. The impact of this theoretical development is that for a large class of programming languages the semantic considerations of correctness and precision come for free by applications of metaresults: it merely suffices to define the analyses, the meaning of the properties studied and to prove the correctness of the language-dependent primitives. The theory then guarantees the correctness of the analyses for all programs. This success is one of the successes needed in order to develop efficient and provably correct implementations directly from semantic definitions.

Incorporating static analysis in a combinator-based compiler

We show how restructuring a denotational definition leads to a more efficient compiling algorithm. Three semantics-preserving transformations ( static replacement, factoring , and combinator selection ) are used to convert a continuation semantics into a formal description of a semantic analyzer and code generator. The compiling algorithm derived below performs type checking before code generation so that type-checking instructions may be omitted from the target code. The optimized code is proved correct with respect to the original definition of the source language. The proof consists of showing that all transformations preserve the semantics of the source language.

Detecting stack-based environments in denotational definitions

We present a statically checkable, sufficient, syntactic criterion for implementing the environment argument in a denotational definition as a global stack variable. We also show how such an environment can be implemented as a compile-time symbol table. If the denotational definition also supports a global store variable, the store can be implemented as run-time primary storage, and a conventional compile/evaluate implementation results. In addition to its value for implementation, the criterion is useful for understanding the relationship between functional and imperative programming language styles. We present two examples.

GL—a denotational testbed with continuations and partial continuations as first-class objects

In this paper we describe GL, a language designed to support interactive experimentation with denotational semantics of programming languages, and the novel features of its interpreter. GL is an expressional language that might best be described as an implementation of lambda calculus augmented with several useful basic data types including 1-values.A unique aspect of the GL environment is that it presents a visible, user-accessible implementation of the continuation semantics of GL. The user is expected to understand a denotational definition of GL, and to interact with the system in terms of that definition. In particular, if a computation is temporarily halted the expression continuation extant at that point can be interactively captured and later applied to other values and stores. The implementation of this feature is via a pair of routines called setjmpup and longjmpup that provide what might be called a partial continuation facility. A partial continuation is a function over stores or store/value pairs that represents execution of a partially executed program from its current state to some later state possibly before its half state. The semantics of partial continuations is interesting, and an extension of GL is presented that contains continuations and partial continuations as first-class objects.The GL environment is fairly complete; it has an experimental polymorphic type inference mechanism that supports self-application and report likely sources of user error in a robust manner, and it has a flexible breakpoint and trace facility that permits program execution to be observed and controlled at a variety of levels of granularity. Moreover, it has been used successfully to teach a graduate course in Theory of Programming Languages.

Detecting global variables in denotational specifications

Sufficient criteria are given for replacing all occurrences of the store argument in a Scott-Strachey denotational definition of a programming language by a single global variable. The criteria and transformation are useful for transforming denotational definitions into compilers and interpreters for imperative machines, for optimizing applicative programs, and for judging the suitability of semantic notations for describing imperative languages. An example transformation of a semantics of a repeat-loop language to one which uses a global store variable is given to illustrate the technique.