Towards a mathematical theory of processes

Much work has been done towards characterizing the semantics of block structured programming languages using the lambda calculus [ 2 ] . Johnston [ 3 ] recently introduced a cell-based approach, called the contour model, for specifying the execution semantics of such languages. This paper relates the two approaches by giving a contour model evaluator for compiled lambda expressions. Section 2 gives the basic definitions needed from the lambda calculus to make the paper self-contained. Section 3 defines the Contour Model Lambda Calculus Machine (CMLCM). Unfortunately publication limitations preclude some worked examples which would greatly aid the reader's understanding. They will be provided in the talk itself and in an expanded version of this paper for the Tutorial Conference on Semantic Models of Computation. Section 4 outlines the structure of the proof of the CMLCM's correctness. And Section 5 is a set of concluding remarks on the significance of the CMLCM.

UDL/I is a hardware design language for ASIC design developed in a Japanese LSI design language standardization project. A formal semantics of UDL/I is presented. There is no established way to define semantics of hardware design languages, because there is no general computation model for them. A definition method of formal semantics for UDL/I and semantics suitable for a standard language are developed. The basic idea is that the semantics of the language should be defined independently of simulators. The language provides an abstract model of hardware. The role of the language designer is to provide an abstract model of hardware which is natural and general for hardware designers and CAD engineers. The authors introduce a novel behavior model of hardware and define the semantics with a nondeterministic feature. >

This book – the first of two volumes – explores the syntactical constructs of the most common programming languages, and sheds a mathematical light on their semantics, while also providing an accurate presentation of the material aspects that interfere with coding. Concepts and Semantics of Programming Languages 1 is dedicated to functional and imperative features. Included is the formal study of the semantics of typing and execution; their acquisition is facilitated by implementation into OCaml and Python, as well as by worked examples. Data representation is considered in detail: endianness, pointers, memory management, union types and pattern-matching, etc., with examples in OCaml, C and C++. The second volume introduces a specific model for studying modular and object features and uses this model to present Ada and OCaml modules, and subsequently Java, C++, OCaml and Python classes and objects. This book is intended not only for computer science students and teachers but also seasoned programmers, who will find a guide to reading reference manuals and the foundations of program verification.

This paper provides an analysis of the meaning–reference problem, as traditionally advanced in the philosophy of language, for imperative programming languages. Addressing the problem is relevant for the philosophy of computer science in the context of the debate of whether simulative programs can be considered representational theories of their simulated systems. This paper challenges the thesis that, since programming languages have semantics, they also have reference, presumably to the external world. First, denotational, operational, game theoretic, and axiomatic semantics are epistemologically analysed to provide a theory of meaning for high-level language programs. It is argued that programming language semantics can be seen, to some extent, under the light of Fregean descriptivism, thereby rejecting the view that it is reference that determines meaning. Secondly, descriptivist, causal, character, and intentionalist theories of reference are examined to argue that meaning is not sufficient for programming languages to determine reference, thereby rejecting the view that meaning determines reference. It is argued that it is the intentions of agents that allow programming language semantics to identify referents. The paper concludes that if the semantics of programming languages may determine their reference, the latter is not to the external world but to the internal operations of the implementation executing them. This does not prevent simulative programs from representing empirical systems, but they do so not on the basis of programming language semantics.

Since descriptive linguistics is essentially the activity of writing language descriptions, ways must now be found of formulating descriptions of languages represented abstractly as equivalence classes of language automata. One needs to know first what sorts of symbolisms might be needed for the specification of such equivalence classes and some of the strategies available for organizing the symbolic descriptions. Then, assuming one wants correct language descriptions, it is important to know how the symbolic descriptions relate to observable evidence, how to gather such evidence, and how to test out the accuracy of a description against that evidence.

An article tries to see a group of semantic web representation and communication means like description logics, semantic networks, RDF model and language, OWL language, RDF CFL etc. taking a part at the development of formal ontologies from a slightly higher (meta) level. A focus has been oriented towards properties that semantic web language ought to have to fulfill according to a semantic web idea. Consequently the article tries to draw by the help of the means above the trip towards a proper semantic-web ontology language fulfilling the main demands of expressivity and also easy-to-use conditions. Even if the development of a semantic web language was until now much more complicated with a taking part of a lot of people or companies the authors of the article try to contribute to an analyzing of the actual state by drawing it as a cloud of demands, streams, events or condition’s fulfilling that at the end would have brought into the world an easy-to-usable semantic web ontology language having all the demands fulfilled. The article moreover shows that a language RDF CFL belongs nowadays to the semantic web family as a unique well usable tool of reasoning within semantic web knowledge bases.

Procedural content generation is becoming more and more relevant to solve the problem of content creation for the ever growing virtual worlds of games, simulations and other applications. However, these procedures are often unintuitive or use vague parameters, making it somewhat difficult for a designer to express his or her creative intent. Even worse, most of these techniques lack an accessible and easy to use interface.We have developed a generic layout solving approach to automatically create sensible content for virtual worlds. In that context, this paper proposes a high-level scene description language that allows designers to specify particular types of scenes. This description language allows designers to easily specify which objects need to be present in a scene, their attributes, and possible interrelationships. Application of the language, based on the rich vocabulary taken from a semantic library, is illustrated with several examples, showing its flexibility, intuitiveness and ease of use.

While much of the current study on quantum computation employs low-level formalisms such as quantum circuits, several high-level languages/calculi have been recently proposed aiming at structured quantum programming. The current work contributes to the semantical study of such languages, by providing interaction-based semantics of a functional quantum programming language, the latter is based on linear lambda calculus and is equipped with features like the! modality and recursion. The proposed denotational model is the first one that supports the full features of a quantum functional programming language, we also prove adequacy of our semantics. The construction of our model is by a series of existing techniques taken from the semantics of classical computation as well as from process theory. The most notable among them is Girard's Geometry of Interaction (GoI), categorically formulated by Abramsky, Haghverdi and Scott. The mathematical genericity of these techniques - largely dueto their categorical formulation - is exploited for our move from classical to quantum.

Complexity characterizations of attribute grammar languages

The abstract interpretation of programs relates the exact semantics of a programming language to a finite approximation of those semantics. In this article, we describe an approach to abstract interpretation that is based in logic and logic programming.Our approach consists of faithfully representing a transition system within logic and then manipulating this initial specification to create a logical approximation of the original specification. The objective is to derive a logical approximation that can be interpreted as a terminating forward-chaining logic program; this ensures that the approximation is finite and that, furthermore, an appropriate logic programming interpreter can implement the derived approximation.We are particularly interested in the specification of the operational semantics of programming languages in ordered logic, a technique we call substructural operational semantics (SSOS). We show that manifestly sound control flow and alias analyses can be derived as logical approximations of the substructural operational semantics of relevant languages.

We describe a first course in program verification and the semantics of programming languages developed for advanced undergraduate and beginning graduate students. The course is intended to support other courses in the curriculum that stress a disciplined approach to programming as well as to prepare students for more advanced courses in semantics and other areas such as software engineering and compiler technology. In order of emphasis, the course covers axiomatic, operational, translational, and denotational semantics. We discuss the development of the course, course prerequisites, the rationale for the selection of the topics covered, and the appropriateness of the course in the curriculum.

While the theory of functional higher-order languages, starting from lambda-calculi, is a well-established research field, it is only in recent years that the operational semantics of higher-order languages with probabilistic operators has started to be extensively studied. A fundamental notion in the semantics of programming languages is that of program equivalence. In higher-order languages, program equivalence is generally formalized as a contextual equivalence [Morris, 1968], which can be hard to prove directly. This has motivated the study of proof techniques for contextual equivalence, from inductive ones, such as logical relations [Andrew Pitts, 2005], to coinductive ones, mainly in the form of bisimulations [Abramsky, 1990]. In this talk I will discuss proof techniques for program equivalence in languages combining higher-order and probabilistic features. Several operational methods, traditionally developed in a deterministic setting, have been adapted to probabilistic higher-order languages [Ales Bizjak and Lars Birkedal, 2015; Dal Lago et al., 2014; Raphaëlle Crubillé and Ugo Dal Lago, 2014]. I will discuss these proof methods and focus on bisimulation-based techniques, showing how probabilities, combined with different language features, force a number of modifications to the definition of bisimulation [Crubillé et al., 2015; Sangiorgi and Vignudelli, 2016].

Language semantics that is formal and mathematically precise, is the essential prerequisite for the design of logics and calculi that permit automated reasoning about programs. The most popular approach to programming language semantics—small step operational semantics (SOS)—is not modular in the sense that it does not separate conceptual layers in the target language. SOS is also hard to relate formally to program logics and calculi. Minimalist semantic formalisms, such as automata, Petri nets, or \(\pi \)-calculus are inadequate for rich programming languages. We propose a new formal trace semantics for a concurrent, active objects language. It is designed with the explicit aim of being compatible with a sequent calculus for a program logic and has a strong model theoretic flavor. Our semantics separates sequential and object-local from concurrent computation: the former yields abstract traces which in a second stage are combined into global system behavior.

Semantics of programming languages: Using Asf+Sdf

Isabelle is a generic meta-logical framework for implementing logical formalisms, and Isabelle/HOL is the specialization of Isabelle for HOL, which stands for Higher Order Logic. In programming language theory, formal semantics is the field concerned with the rigorous mathematical study of the meaning of programming languages. In this paper we develop a relational denotational semantics for a small imperative programming language and implement it as a theory in Isabelle/HOL. We give special attention to the specification of monotonic fix point functional for loops and provide non-trivial proofs of interesting lemmas and properties with the structured proof language Isar.