Programming Language Semantics

This paper presents a modular and extensible style of language speci cation based on metacomputations. This style uses two monads to factor the static and dynamic parts of the speci cation, thereby staging the speci cation and achieving strong binding-time separation. Because metacomputations are de ned i n t e r m s of monads, they can be c onstructed m o dularly and extensibly using monad transformers. A number of language constructs are speci ed: expressions, controlow, imperative features, and block structure. Metacomputation-style speci cation lends itself to semantics-directed c ompilation, which we demonstrate by creating a modular compiler for a block-structured, imperative while language.

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.

The aim of the project is to develop a prototype for a generator of argument structure or valency realizations in terms of syntagmatic and paradigmatic combinations of Spanish, German and French nouns. The two main applications of the tool prototype we are aiming to develop, are (1) the generation of noun phrases as argument structure realizations that follow patterns related to semantic features, for the creation of corpus and web query strings; and (2) the knowledge-based generation of simple and complex noun phrases that are acceptable in a coherent sentence context. An essential step in developing these applications is the systematic description of the valency-related syntagmatic and paradigmatic properties of argument combinations. To this end, we have devised a methodology based on bidirectional mutual enrichment (bottom-down and bottom-up). With the aim of generating argument surface realizations, we will mainly use lexical knowledge represented in wordnets for Spanish, Germa...

En 2019, les 30èmes journées francophones des langages applicatifs (JFLA) se déroulent aux Rousses dans le Jura. Après une édition méditerranéenne à Banyuls-sur-Mer, les JFLA retrouvent donc une nouvelle fois la montagne. Chaque année, les JFLA réunissent, dans un cadre convivial, des concepteurs, des développeurs et des utilisateurs des langages fonctionnels, des assistants de preuve et des outils de vérification de programmes en présentant des travaux variés, allant des aspects les plus théoriques aux applications industrielles. Cette année, nous avons sélectionné 11 articles de recherche et 4 articles courts. Les thématiques sont variées : preuve formelle, exécution symbolique, vérification de programmes, langages de programmation, mais aussi théorie des catégories et programmation synchrone. La sélection a été faite par les membres du comité de programme à partir des articles reçus après les 18 soumissions de résumés. Ceux-ci ont été aidés dans leur travail par des rapporteurs extérieurs que nous souhaitons remercier ici : Timothy Bourke, Adrien Guatto et Pascal Schreck. Cette année, le format des papiers courts permet de faire connaître à la communauté des JFLA des travaux en cours ou bien récemment publiés. Pour compléter le programme, nous bénéficions de deux cours, l'un par Guillaume Melquiond sur les liens entre l'arithmétique des ordinateurs et les preuves formelles; l'autre par Pierre-Marie Pédrot sur la prise en compte des effets dans la théorie des types. Nous assisterons également à deux exposés invités, le premier par Ilaria Castellani sur les types de session qui peuvent être vus comme une abstraction pour les protocoles de communication et le second par Pierre Courtieu sur l'étude formelle de protocoles de déplacement de robots. Enfin cette 30ème édition des JFLA est l'occasion de se retrouver et d'observer le chemin parcouru depuis quelques années. Nous avons sélectionné les 3 orateurs les plus prolifiques des 10 dernières éditions (2009 à 2018). Tous les 3 ont, chacun en ce qui les concerne, présenté au moins 7 contributions aux JFLA en 10 ans. Il s'agit de Jean-Christophe Filliâtre qui nous fera une synthèse de ses 25 années d'expérience(s) en programmation avec OCaml, de Louis Mandel qui fera un tour d'horizon de la programmation synchrone aux JFLA et d'Alan Schmitt qui nous parlera de sémantiques formelles certifiées. Nous remercions chaleureusement la cellule Congrès de l'Université de Strasbourg qui nous a accompagnée sur le chemin logistique et administratif des JFLA 2019: Christine Guibert, et surtout Marion Oswald, qui a été présente de bout en bout pour gérer tous les aléas administratifs rencontrés. Enfin, nos sincères remerciements à nos généreux sponsors. Cette année encore, les étudiants orateurs ne paient pas les frais d'hébergement et d'inscription. Merci au laboratoire ICube de l'Université de Strasbourg, au CEA LIST, au GDR GPL, à OcamlPro et à TrustInSoft.

We have created CABERNET, a Controlled Nature Language (CNL) based approach to program creation. CABERNET allows programmers to use a simple outline-based syntax. This allows increased programmer efficiency and syntax flexibility. CNLs have successfully been used for writing requirements documents. We propose taking this approach well beyond this to fully functional programs. Through the use of heuristics and inference to analyze and determine the programmer's intent we are able to create fully functional mobile applications. The goal is for programs to be aligned with the way that the humans think rather than the way computers process information. Through the use of templates a CABERNET application can be processed to run on multiple run time environments. Because processing of a CABERNET program file results in native application program performance is maintained.

By paying more attention to semantics-based tool generation, programming language semantics can significantly increase its impact. Ultimately, this may lead to "Language Design Assistants" incorporating substantial amounts of semantic knowledge.

We argue that classical programming languages are based on a fundamentally mistaken emphasis on the operational aspect of computation. These languages are seen as the means by which the programmer brings about particular kinds of operational activity (such as procedure calling or message passing). We suggest an alternate philosophy which places the emphasis on static, extensional (mathematical) concepts such as that of function or sequence. We outline a simple functional language (Luswim) based on these principles. The Luswim programmer specifies the desired output, and operational concepts such as dataflow, message passing or coroutine linkage can be used to 'evaluate' the specification. Operational activity occupies its proper place, namely as means to an end rather than an end in itself.

This paper presents XeraWord, an innovative tool for automatically generating nominal phrases. XeraWord can be used for different tasks, ranging from teaching languages to the creation of examples in lexicography, or even for the development of resources for natural language processing. In this area, Xera was the first experiment, allowing the automatic generation of nominal phrases in three languages: German, French and Spanish. This tool was extended to support other languages, namely, Portuguese and Galician. We start by presenting the theory behind the development of Xera and its new version, XeraWord, namely, the applied base methodology, and the natural language processing resources used to support it. Then, TraduWord, a tool specifically developed to construct resources for new languages, is presented. This tool allows the semi-automatic translation of the data required for the nominal phrase generation. For this, we discuss its advantages and disadvantages, analysing the quality of the translated resources, as well as the amount of manual work required to validate and correct these resources.

Ce document présente des défis liés au développement de la combinatoire certifiée, définie comme l'application des méthodes formelles du génie logiciel à la recherche en combinatoire. Ce défi est lié aux thématiques du groupe de travail LTP (Langages, Types et Preuves) du GdR GPL. Il a été alimenté par des interactions au sein de ce groupe.

This paper describe the multithreaded execution and data race detectors which are commonly viewed as debugging tools.The C++ Standard defines single-threaded program execution. Basically, multithreaded execution requires a much more refined memory and execution model. C++ threading libraries are in the awkward situation of specifying an extended memory model for C++ in order to specify program execution. We suggest integrating a memory model suitable for multithreaded execution in the C++ Standard. We wants to make fast and error free program .but ideally it is not possible To overcome this problem we give first concept threading and ssecond concept in this paper is data race detector. They would allow us to give precise, simple, and safe semantics to shared variables in multithreaded programs, a problem that has so far defied a complete solution. Keyword:-atomicity,data race. I INTRODUCTION multithreaded execution. is use in most of today's programming. C++ is commonly used as part of multithreaded applications, sometimes with either direct calls into an OSprovided threading library or with the aid of an intervening layer that provides a platform-neutral interface. Properties critical for reliable, efficient, and correct multithreaded execution are left unspecified The C++ Standard specifies program execution in terms of observable behavior, which in turn describes sequential execution on an implicitly singlethreaded abstract machine. The main sketch of attack is: 1. Specification of an abstract memory model describing the interactions between threads and memory. 2. Application of this model to existing aspects of the C++ specification to replace the current implicitly sequential semantics. This will entail new constraints on how compilers can emit and optimize code. In particular, this will entail a reworking of the specification of volatile to provide useful multithreaded semantics. 3. Introduction of a small number of standard library classes providing standardized access to atomic update operations (such as compare_and_set). These classes will have multithreaded semantics integrated with the above

In the model-based development context, metamodel-based languages are increasingly being defined and adopted either for general purposes or for specific domains of interest. However, metalanguages such as the MOF (Meta Object Facility)-combined with the OCL (Object Constraint Language) for expressing constraints-used to specify metamodels focus on structural and static semantics but have no built-in support for specifying behavioral semantics. This paper introduces a formal semantic framework for the definition of the semantics of metamodel-based languages. Using metamodelling principles, we propose several techniques, some based on the translational approach while others based on the weaving approach, all showing how the Abstract State Machine formal method can be integrated with current metamodel engineering environments to endow language metamodels with precise and executable semantics. We exemplify the use of our semantic framework by applying the proposed techniques to the OMG metamodelling framework for the behaviour specification of the Finite State Machines provided in terms of a metamodel.

Proxies are a powerful approach to implement meta-objects in object-oriented languages without having to resort to metacircular interpretation. We introduce such a meta-level API based on proxies for Javascript. We simultaneously introduce a set of design principles that characterize such APIs in general, and compare similar APIs of other languages in terms of these principles. We highlight how principled proxy-based APIs improve code robustness by avoiding interference between base and meta-level code that occur in more common reflective intercession mechanisms.

We define a strongly normalising proof-net calculus corresponding to the logic of strongly compact closed categories with biproducts. The calculus is a full and faithful representation of the free strongly compact closed category with biproducts on a given category with an involution. This syntax can be used to represent and reason about quantum processes.

We present an initial draft of the ''Luminous'' interactive interpreter for a new dialect of the functional dataflow language Lucid. Luminous is not the first implementation of Lucid but it is novel in several ways. First, the dialect is two dimensional (has a space as well as a time dimension) with special space operators. And it performs dimensional analysis to determine, for each program variable, which dimensions may be required to evaluate a variable and which are irrelevant. This information is vital for producing output and for avoiding expensive redundancy in the cache. Also, Luminous is interactive: the user can demand the value of an arbitrary expression and immediately see the results in an appropriate form, depending on the dimensionality of the expression. The user can also alter existing definitions and re-demand the value of expressions, to see the effect of the change. Unlike previous Lucid implementation, Luminous operates directly on the source-it doesn't build a parse tree. The source is 'dismantled' into elementary equations in a bottom-up procedure based on program transformation which skips building a parse tree. Dismantling is a non deterministic distributable dataflow procedure. This could become very important when (in the future) we deal with programs millions of lines long, when parsing is a major problem. The final result of dismantling is an (unordered) set of 'atomic' equations-so called because they cannot be simplified, each consisting of a simple variable equated to an expression consisting of a single operator applied to arguments, which are also simple variables (or literals). Converting a program to a set of atomic equations (another first for Luminous) vastly simplifies evaluation and static analysis. We discuss shortcomings of the current interpreter, the most glaring of which is the lack of user defined stream transformations.

We present an initial draft of the ''Luminous'' interactive interpreter for a new dialect of the functional dataflow language Lucid. Luminous is not the first implementation of Lucid but it is novel in several ways. First, the dialect is two dimensional (has a space as well as a time dimension) with special space operators. And it performs dimensional analysis to determine, for each program variable, which dimensions may be required to evaluate a variable and which are irrelevant. This information is vital for producing output and for avoiding expensive redundancy in the cache. Also, Luminous is interactive: the user can demand the value of an arbitrary expression and immediately see the results in an appropriate form, depending on the dimensionality of the expression. The user can also alter existing definitions and re-demand the value of expressions, to see the effect of the change. Unlike previous Lucid implementation, Luminous operates directly on the source-it doesn't build a parse tree. The source is 'dismantled' into elementary equations in a bottom-up procedure based on program transformation which skips building a parse tree. Dismantling is a non deterministic distributable dataflow procedure. This could become very important when (in the future) we deal with programs millions of lines long, when parsing is a major problem. The final result of dismantling is an (unordered) set of 'atomic' equations-so called because they cannot be simplified, each consisting of a simple variable equated to an expression consisting of a single operator applied to arguments, which are also simple variables (or literals). Converting a program to a set of atomic equations (another first for Luminous) vastly simplifies evaluation and static analysis. We discuss shortcomings of the current interpreter, the most glaring of which is the lack of user defined stream transformations.

La théorie des preuves automatiques est une méthode très puissante pour vérifier qu'un système informatique satisfait une propriété. Parfois le processus de vérification n'est pas rassurant. Dans plusieurs cas, une certification de la preuve de la propriété, elle-même, est exigée et c'est le défi majeur de la vérification automatique. Parce que la preuve, elle est souvent de taille énorme de telle sorte qu'il soit impossible à l'homme de la faire manuellement. La certification d'une preuve est soumise à des conditions, lune des plus importantes étant la correction de l'outil..

Les preuves par récurrence sont de plus en plus employees dans la théorie des preuves. La descente Innie est un ancien raisonnement de récurrence. À nos jours, elle est devenue largement utilisable. Dans ce rapport, On l'adoptee pour valider des preuves par saturation. Ces deux techniques, ensemble ont construit un environnement pour concevoir des outils de vérification corrects. Nous montrons comment l'appliquer à la vérification de la preuve de problème de Robbins. La correction de la preuve est certifiée par coq.

In this paper, we give an overview of our current work on introducing context as first-class objects in Lucid. It allows us to write programs in Lucx (Lucid enriched with context) in a high level of abstraction which is closer to the problem domain. We include a discussion on context theory, representation of context aggregations, and the syntax and semantic rules of Lucx. The implementation of Lucx in GIPSY, a platform under development for compiling Lucid family of languages, is also discussed.

In this work we model the ACME (a fictitious company name) "printer case incident" and make its specification in Forensic Lucid, a Lucid-and intensional-logic-based programming language for cyberforensic analysis and event reconstruction specification. The printer case involves a dispute between two parties that was previously solved using the finite-state automata (FSA) approach, and is now redone in a more usable way in Forensic Lucid. Our simulation is based on the said case modeling by encoding concepts like evidence and the related witness accounts as an evidential statement context in a Forensic Lucid program, which is an input to the transition function that models the possible deductions in the case. We then invoke the transition function (actually its reverse) with the evidential statement context to see if the evidence we encoded agrees with one's claims and then attempt to reconstruct the sequence of events that may explain the claim or disprove it.

Faustine is the first interpreter for the digital audio signal processing language Faust and its vector extension. This domainspecific language for sample-based audio is highly expressive and can be efficiently compiled. Faustine has been designed and implemented, in OCaml, to validate the Faust multirate vector extension proposed in the literature, without having to modify the sophisticated Faust scalar compiler. Moving to frame-based algorithms such as FFT is of paramount importance in the audio field and, more broadly, in the multimedia signal processing domain. Via the actual implementation of multidimensional FFT and morphological image processing operations, Faustine, although unable to process data in real time, illustrates the possible advantages and shortcomings of this vector extension as a language design proposal. More generally, our paper provides a new use case for the vision of interpreters as lightweight software platforms within which language design and implementation issues can be easily assessed without incurring the high costs of modifying large compiler platforms.

We explore the intersection of interactive theorem proving and digital signal processing through the use of web-based, rich interfaces. Traditionally, the barrier to entry to interactive theorem proving has been high. Provers are complex systems using obscure programming languages, and libraries may be underdocumented and use formalisms and notations far from the standard domain-specific practice. Thus, it doesn't come at a surprise that interactive theorem proving has seldom been explored in the the digital signal processing community. In previous work [1,2], we formalized several DSP tools and concepts using the Coq theorem prover [3]. [1] presents a simplified model Faust [4], a programming language tailored to audio DSP. The formalization allows to reason about Faust programs and prove typical properties like filter stability. In [2], we mechanized some theory of the Discrete Fourier Transform, following [5], and proving the main theorems. In our opinion, both developments a...

We describe an interpreter for pLucid, a member of the Luci d family of functional dataflow languages. In appearance, pLuci d is similar to Landin's Iswim, exept that individual variables an d expressions denote streams (infinite sequences of data items) , and function variables denote filters (stream-to-strea m transformations). The actual data objects in pLucid (th e components of streams) are those of POP2 : numbers, strings , words, and lists. The 'inner syntax' (infix operations , conventions for denoting constants) are those of POP2 as well. The interpreter (which was written in C) is eductive : it uses a tagged demand-driven scheme. Demands for values in th e output stream generate demands for values of other variable s internal to the program. These demands, and the value s returned in response, are tagged according to "time" (sequenc e index) and place (node in the tree of function calls). Once computed, values are stored in an associative memory (th e "warehouse") in case they are demanded again later in th e computation. The warehouse is periodically cleaned out using a heuristic called the "retirement plan". The heuristic is not perfect, but does not have to be : in an eductive computation , the program is not altered as in reduction. If discarded value s are needed again, they can be recomputed .

The purpose of this paper is to demonstrate that first-order functional programs can be transformed into intensional programs of nullary variables, in a semantics preserving way. On the foundational side, the goal of our study is to bring new insights and a better understanding of the nature of functional languages. From a practical point of view, our investigation provides a formal basis for the tagging mechanism that is used in the implementation of first-order functional languages on dataflow machines.

Faustine is the first interpreter for the digital audio signal processing language Faust and its vector extension. This domainspecific language for sample-based audio is highly expressive and can be efficiently compiled. Faustine has been designed and implemented, in OCaml, to validate the Faust multirate vector extension proposed in the literature, without having to modify the sophisticated Faust scalar compiler. Moving to frame-based algorithms such as FFT is of paramount importance in the audio field and, more broadly, in the multimedia signal processing domain. Via the actual implementation of multidimensional FFT and morphological image processing operations, Faustine, although unable to process data in real time, illustrates the possible advantages and shortcomings of this vector extension as a language design proposal. More generally, our paper provides a new use case for the vision of interpreters as lightweight software platforms within which language design and implementation issues can be easily assessed without incurring the high costs of modifying large compiler platforms.

In this paper, we discuss different properties of positive elements in the tensor product of two C*-algebras. Considering the cone of positive elements in a C*-algebra , we define a cone norm on the set of Hermitian elements of. Some results regarding positive forms in the tensor product are also derived here.

In a recent paper, a realizability technique has been used to give a semantics of a quantum lambda calculus. Such a technique gives rise to an infinite number of valid typing rules, without giving preference to any subset of those. In this paper, we introduce a valid subset of typing rules, defining an expressive enough quantum calculus. Then, we propose a categorical semantics for it. Such a semantics consists of an adjunction between the category of distributive-action spaces of value distributions (that is, linear combinations of values in the lambda calculus), and the category of sets of value distributions.

In 1981 Structural Operational Semantics (SOS) was introduced as a systematic way to define operational semantics of programming languages by a set of rules of a certain shape [56]. Subsequently, the rule format became object of study. Using so-called Transition System Specifications (TSSs) several authors syntactically restricted the format of rules and showed several useful properties about the semantics induced by any TSS adhering to the format. This has resulted in a line of research proposing several syntactical rule formats and associated meta-theorems. Properties that are guaranteed by such rule formats range from well-definedness of the operational semantics and compositionality of behavioral equivalences to securityand probability-related issues. In this paper, we provide an initial hierarchy of SOS rules formats and meta-theorems formulated around them.

We describe in detail the new reflection API of the upcoming Javascript standard. The most prominent feature of this new API is its support for creating proxies: virtual objects that behave as regular objects, but whose entire "meta-object protocol" is implemented in Javascript itself. Next to a detailed description of the API, we describe a more general set of design principles that helped steer the API's design, and which should be applicable to similar APIs for other languages. We also describe access control abstractions implemented in the new API, and provide an operational semantics of an extension of the untyped λ-calculus featuring proxies.

This paper addresses the problem of code optimization for Real-Time and Embedded Systems (RTES). Such systems are designed using Model-Based Development (MBD) approach that consists of performing three major steps: building models, generating code from them and compiling the generated code. Actually, during the code generation, an important part of the modeling language semantics which could be useful for optimization is lost, thus, making impossible some optimizations achievement. This paper shows how adding a new level of optimization at the model level results in a more compact code. It also discusses the impact of the code generation on optimization: whether this step promotes or prevents optimizations. We conclude on a proposal of a new MBD approach containing only steps that advance optimization: modeling and compiling steps.

When writing functional interpreters, there are two things which need to be taken care of when having modularity in mind: syntax and semantics. Previous papers have presented methods, based on subtypes and monad transformers, for dealing with semantics. This paper combines these methods with a method, based on catamorphisms, for dealing with syntax. Subtypes, monad transformers and catamorphisms make it possible to write library code which can be used for building functional interpreters which are composed of reusable components.

An examination of these compilers shows the strengths and weaknesses of this approach. The final section discusses the relationship between portability and a universal distribution format: ANDF cannot make programs portable; it provides the mechanisms necessary to support portable programs. 2. UNCOL What was UNCOL? UNCOL, a Universal Computer-Oriented Language, is the general name for a group of proposals for a universal intermediate language for compilers. UNCOL's goal was quick and economic production of compilers for a full range of languages on new machine architectures. Steel presents the economic justification clearly: Th[e] capital investment in a translator [i.e. compiler] would be well advised if our concern were for a single machine and a single problem oriented language…. In our firm insistence on many machines and many languages, however, the requisite investment is increased multiplicatively…. A primary objective of the effort whose direction is outlined in the following pages is a reduction in the time and money required to live in this changing environment.

In previous work we proved that, for categories of free finite-dimensional modules over a commutative semiring, linear compact-closed symmetric monoidal structure is a property, rather than a structure. That is, if there is such a structure, then it is uniquely defined (up to monoidal equivalence). Here we provide a novel unifying category-theoretic notion of symmetric monoidal structure with local character, which we prove to be a property for a much broader spectrum of categorical examples, including the infinite-dimensional case of relations over a quantale and the non-free case of finitely generated modules over a principal ideal domain.

In many different fields of science, it is useful to characterize physical states and processes as resources. Chemistry, thermodynamics, Shannon's theory of communication channels, and the theory of quantum entanglement are prominent examples. Questions addressed by a theory of resources include: Which resources can be converted into which other ones? What is the rate at which arbitrarily many copies of one resource can be converted into arbitrarily many copies of another? Can a catalyst help in making an impossible transformation possible? How does one quantify the resource? Here, we propose a general mathematical definition of what constitutes a resource theory. We prove some general theorems about how resource theories can be constructed from theories of processes wherein there is a special class of processes that are implementable at no cost and which define the means by which the costly states and processes can be interconverted one to another. We outline how various existing resource theories fit into our framework. Our abstract characterization of resource theories is a first step in a larger project of identifying universal features and principles of resource theories. In this vein, we identify a few general results concerning resource convertibility.

We address the problem of curvature estimation from sampled smooth surfaces. Building upon the theory of normal cycles, we derive a definition of the curvature tensor for polyhedral surfaces. This definition consists in a very simple and new formula. When applied to a polyhedral approximation of a smooth surface, it yields an efficient and reliable curvature estimation algorithm. Moreover, we bound the difference between the estimated curvature and the one of the smooth surface in the case of restricted Delaunay triangulations.

Nautilus is a concurrent anticipatory programming language based on the object-oriented language GNOME which is a simplified and revised version of OBLOG. A semantics for Nautilus is given by Nonsequencial Automata, that is a categorial semantic domain based on labeled transition system with full concurrency, where a class of morphisms stands for anticipation. The semantics of an object in Nautilus is given by an anticipation morphism, which is viewed as a special automaton morphism where target automata, called base, is determined by the computations of a freely generated automata able to simulate any object specified over the involved attributes, and the source automata is a relabelled restriction of the base. In order to introduce the anticipation of Nautilus, some examples are presented depicting the features of the language.

A formal refinement calculus targeted at system-level descriptions in the IEEE standard hardware description language VHDL is described here. Refinement can be used to develop hardware description code that is “correct by construction”. the calculus is closely related to a Hoare-style programming logic for VHDL and real-time systems in general. That logic and a semantics for a core subset of VHDL are described. The programming logic and the associated refinement calculus are shown to be complete. This means that if there is a code that can be shown to implement a given specification, then it will be derivable from the specification via the calculus.

We report on the progress of a constructive mechanization for a small subset of signal processing theory, built upon the SSREFLECT and MATHCOMP libraries. The development was started to provide mechanized semantics for audio programming languages. Currently, we have formalized several standard properties of the Discrete Fourier Transform, such as its unitary matrix form and its power and convolution theorems. Future goals include transfer functions and constant overlap-add processing. At the workshop, we aim to discuss the needs and limits of our current approach, surveying some mathematical concepts not covered by existing libraries, and similar efforts in other frameworks and theorem provers.

We study a notion of observation for concurrent processes which allows the observer to see the distributed nature of processes, giving explicit names for the location of actions. A general notion of bisimulation related to this observation of distributed systems is introduced. Our main result is that these bisimulation relations, particularized to a process algebra extending CCS, are completely axiomatizable. We discuss in detail two instances of location bisimulations, namely the location equivalence and the location preorder.

This paper presents a methodology for automatically validating program transformation rules that are part of a calculus for Java source code verification. We target the Java Dynamic Logic calculus which is implemented in the interactive prover of the KeY system. As a basis for validation, we take an existing SOS style rewriting logic semantics for Java, formalized in the input language of the Maude system. That semantics is 'lifted' to cope with schematic programs like the ones appearing in program transformation rules. The rewriting theory is further extended to generate valid initial states for involved program fragments, and to check the final states for equivalence. The result is used in frequent validation runs over the relevant fragment of the calculus in the KeY system.

We propose an algebraic approach to block diagram construction as an alternative to the classical graph ap-proach inspired by dataflow models. The proposed al-gebra is based on three binary operations of construc-tion : sequential, parallel and recursive constructions. These operations can be seen as high level connection schemes that set several connections at once in order to combine two block diagrams to form a new one. Al-gebraic representations have interesting application for visual languages based on block diagrams and are use-ful to specify the formal semantic of this languages.

Robots and other cyber-physical systems are held to high standards of safety and reliability, and thus one must be confident in the correctness of their software. Formal verification can provide such confidence, but programming languages that lend themselves well to verification often do not produce executable code, and languages that are executable do not typically have precise enough formal semantics. We present MARVeLus, a stream-based approach to combining verification and execution in a synchronous programming language that allows formal guarantees to be made about implementation-level source code. We then demonstrate the end-to-end process of developing a safe robotics application, from modeling and verification to implementation and execution.