Operational Semantics Research Articles

A metalanguage for guarded iteration

Notions of guardedness serve to delineate admissible recursive definitions in various settings in a compositional manner. In recent work, we have introduced an axiomatic notion of guardedness in symmetric monoidal categories, which serves as a unifying framework for various examples from program semantics, process algebra, and beyond. In the present paper, we propose a generic metalanguage for guarded iteration based on combining this notion with the fine-grain call-by-value paradigm, which we intend as a unifying programming language for guarded and unguarded iteration in the presence of computational effects. We give a generic (categorical) semantics of this language over a suitable class of strong monads supporting guarded iteration, and show it to be in touch with the standard operational behaviour of iteration by giving a concrete big-step operational semantics for a certain specific instance of the metalanguage and establishing soundness and (computational) adequacy for this case.

Building a Document-Oriented Warehouse Using NoSQL

The traditional data warehousing approaches should adapt to take into consideration novel needs and data structures. In this context, NoSQL technology is progressively gaining a place in the research and industry domains. This paper proposes an approach for building a NoSQL document-oriented warehouse (DocW). This approach has two methods, namely 1) document warehouse builder and 2) NoSQL-Converter. The first method generates the DocW schema as a galaxy model whereas the second one translates the generated galaxy into a document-oriented NoSQL model. This relies on two types of rules: structure and hierarchical rules. Furthermore, in order to help understanding the textual results of analytical queries on the NoSQL-DocW, the authors define two semantic operators S-Drill-Up and S-Drill-Down to aggregate/expand the terms of query. The implementation of our proposals uses MangoDB and Talend. The experiment uses the medical collection Clef-2007 and two metrics called write request latency and read request latency to evaluate respectively the loading time and the response time to queries.

A logical and graphical framework for reaction systems

Reaction Systems (RSs) are a successful computational framework inspired by biological systems. A RS pairs a set of entities with a set of reactions over them. Entities can be used to enable or inhibit each reaction, and are produced by reactions. Entities can also be provided by an external context sequence to simulate in silico biological experiments. In this paper we define an extension of RSs considering nondeterministic and recursive context operators, and give an original labelled transition system (LTS) for extended RSs in the structural operational semantics (SOS) style. Thanks to extended contexts, a single LTS can now account for several biological experiments. The rich information recorded in transition labels is useful to guarantee the compositionality of SOS inference rules as well as to define an assertion language to tailor behavioural and logical equivalences on some specific properties or entities. The SOS rules have been also exploited to design a flexible prototype implementation in logic programming that allows to inspect the LTS and to extract useful information when performing experiments on a RS. Our implementation provides a rapid prototyping tool for (extensions of) RSs, with a user friendly online interface to our interpreter. A parser allows to introduce the logical formulas and the contexts using the usual comfortable concrete syntax. The user can visualise and inspect the LTS for a RS and make some analysis of its underlying computation patterns, can check if the main RS satisfies a given property and if it is equivalent to a second adversarial RS. Finally, the SOS approach is suited to drive additional enhancements of RSs.

Intuitionistic multi-agent subatomic natural deduction for belief and knowledge

Abstract This paper proposes natural deduction systems for the representation of inferences in which several agents participate in deriving conclusions about what they believe or know, where belief and knowledge are understood in an intuitionistic sense. Multi-agent derivations in these systems may involve relatively complex belief (resp. knowledge) constructions which may include forms of nested, reciprocal, shared, distributed or universal belief/knowledge as well as attitudes de dicto/re/se. The systems consist of two main components: multi-agent belief bases which assign to each agent a subatomic system that represents the agent’s beliefs concerning atomic sentences and a set of multi-agent labelled rules for logically compound formulae. Derivations in these systems normalize. Moreover, normal derivations possess the subexpression property (a refinement of the subformula property) which makes them fully analytic. Relying on the normalization result, a proof-theoretic approach to the semantics of the intensional operators for intuitionistic belief/knowledge is presented which explains their meaning entirely by appeal to the structure of derivations. Importantly, this proof-theoretic semantics is autarkic with respect to its foundations as the systems (unlike, e.g. external/labelled proof systems which internalize possible worlds truth conditions) are not defined on the basis of a possible worlds semantics. Detailed applications to a logical puzzle (McCarthy’s three wise men puzzle) and to a semantical difficulty (Geach’s problem of intentional identity), respectively, illustrate the systems. The paper also provides comparisons with other approaches to intuitionistic belief/knowledge and multi-agent natural deduction.

Psychological, pedagogical and methodological principles of teaching dialogic foreign language speaking and the problem of classification of exercises

The article provides a theoretical analysis of psychological, pedagogical and methodological principles of teaching dialogic speaking. The relevance of the study is related to the need for scientific development and implementation of a model related to teaching dialogic speaking, which will effectively develop quality skills and relevant competencies. The methodological basis for teaching dialogic speaking is the systemic dynamic unity of interconnected and interdependent situational semantic and linguistic characteristics of this form of speaking realised in the model. The article pays attention to the main provisions of the theory of verbal communication which are a real basis for building a system of situational teaching / learning of dialogic speaking within a single complex “situation – meaning – language”. The gradual approximating of educational situations to natural dialogue is based on a number of well-known didactic principles, the observance of which is considered by the author as an important component of the teaching / learning system. Theoretical analysis of the problem regarding classification of exercises for teaching dialogic speaking as the main element of the educational process has been carried out. Basing on the analysis, it has been determined that an exercise should comprise situational, semantic (meaning-centred) and linguistic characteristics of dialogic speech; whereas their systematic application, while being trained, should be aimed at mastering stylistically marked units alongside syntactic and lexical-syntactic phenomena typical for conversational style of dialogic speaking, as well as at practicing a set of operations of semantic order and operations related to the memory peculiarities. Taking into account all these aspects will allow building an effective model of teaching / learning, namely to clearly formulate the requirements to the main component of the education system, to select the most effective ones, as well as to integrate them into an overall model aimed at developing skills and abilities of dialogic foreign language speaking.

Operational semantics with semicommutations

We propose an operational semantics where the execution of instructions of a program is not necessarily in the order in which they are given in the program. In other words, an instruction might be executed before its preceding instructions have been executed. The idea is that such an execution mechanism can capture some optimizations that a compiler or a runtime environment might apply to the program. In our framework, the allowed reorderings are described by a binary commutation relation on the set of instructions, or, more generally, by a semicommutation relation. We then further extend this basic framework to allow more intricate reordering behaviours. As an experiment, we describe a fragment of the multicopy-atomic ARM memory model in this framework and validate a prototype of it against a number of litmus-tests.

Multi-task Ada code generation from synchronous dataflow programs on multi-core: Approach and industrial study

• Proposing a new multi-task code generation method for the synchronous language SIGNAL. • Proposing a common multi-task structure, called Virtual Multi-Tasks (VMT), for different platform targets of our compiler. • The formal syntax and the operational semantics of VMT are mechanized in the proof assistant Coq. • Concurrent JobQueue is adopted for implementing the platform-dependent multi-task code to provide fine-grained parallelization. • A real-world aerospace industrial case study is used to show the feasibility of the method presented in the paper. The growing trend to use multi-core processors to get more performance is increasingly present in safety-critical systems. Synchronous dataflow programming is naturally well-suited to parallel execution, thanks to the fact that all data dependencies are always explicit. MiniSIGNAL is a multi-task code generation tool for the synchronous dataflow language SIGNAL. The existing MiniSIGNAL code generation strategies mainly consider coarse-grained parallelism based on Ada multi-task model. However, when we applied it to industrial case studies, this code generation scheme has revealed inefficient: architecture aspects of the target platform have to be taken into account to achieve fine-grained parallelism. To generate more efficient target code from industrial cases, this paper presents a new multi-task code generation method for MiniSIGNAL. Starting at the level of synchronous clocked guarded actions (S-CGA) which is an intermediate language for the compilation process of MiniSIGNAL, the transformation consists of two parts: at the platform-independent level, transforming the S-CGA representation to an abstract multi-task structure (called Virtual Multi-Tasks, VMT); at the platform-dependent level, adopting the thread pool pattern concurrent JobQueue to support fine-grained parallel Ada code generation from the VMT structure. Moreover, the formal syntax and the operational semantics of VMT are mechanized in the proof assistant Coq. Finally, the effectiveness of our approach is illustrated by an application of the real-world Guidance, Navigation and Control system.

Semantic Operation of Place in the Legendary Movie

يعد المكان من العناصر الفنية المهمة في الفيلم والذي من خلاله تدور الأحداث في مختلف الفنون والآداب وبانعدامه لا يوجد من يثور الأحداث، فالمكان ضروري للأشياء التي نميزها, والحقيقة الأولى في السينما هي المكان والتي لا يمكن الاستغناء عنها على مستوى الفيلم أو على مستوى المشهد أو اللقطة السينمائية التي لا يمكن تفريغها من محتواها المكاني . فالشخصيات تظل دوما موجودة في مكان شاغلة حيزا منه، ومع ذلك فهو ليس مجرد الوعاء الحاوي للحدث سينمائيا، ويرى الباحث أهمية أن يتم الكشف عنها ورصدها في هذا البحث الذي قسم إلى أربعة فصول كانت على النحو الآتي: (الإطار المنهجي) الذي ضم مشكلة البحث التي تبلورت بالسؤال المعرفي (ما هي الإشتغالات الدلالية للمكان في الفيلم الإسطوري؟)، ثم هدف البحث في الكشف عن الإشتغال الدلالي للمكان في الفيلم الإسطوري ، وقد تحدد بالحدود الزمنية (2010) ومكانيا الفيلم الإسطوري في السينما الأمريكية ، فضلا عن التعريفات الإجرائية لمصطلحات البحث. أما (الإطار النظري) فقد قسم إلى مبحثين، الأول بعنوان (دلالات المكان في الفيلم السينمائي)، والثاني بعنوان (الإسطورة والسينما)، وصولا إلى أهم مؤشرات الإطار النظري، أما (إجراءات البحث) والذي تناول (منهج البحث، مجتمع البحث، أداة البحث، وحدة التحليل، عينة البحث)، و(النتائج والاستنتاجات) خصص هذا الفصل لمناقشة نتائج دراسة العينة والتوصل إلى أهم الإستنتاجات وختم الباحث دراسته بقائمة المصادر.

GraphRedex: Look at your research

AbstractA significant aspect of designing new programming languages is to define their operational semantics. Working with a pen and paper version of such a semantics is notoriously difficult. For this reason, tools for computer aided semantics engineering were created. Many of these tools allow programmers to execute their language's operational semantics. An executable semantics makes it easier to verify whether the execution of a program leads to the desired result. When a program exhibits unexpected behavior, the programmer can consult the reduction graph to see what went wrong. Unfortunately, visualization of these graphs is currently not well‐supported by most tools. Consequently, the comprehension of errors remains challenging. In this article, we present GraphRedex an open‐source tool that empowers language designers to interactively explore their reduction graphs, offering three main benefits. First, a global exploration mode allows users to obtain a bird's‐eye overview of the reduction graph and learn its high level workings. Second, a local exploration mode lets the programmer closely interact with the individual reduction rules. Third, our query interface allows the programmer to filter out and highlight specific regions of the reduction graph. We evaluated our tool by carrying out a user study showing that participants comprehend programs on average twice as fast while being able to answer questions more accurately. Finally, we demonstrate how GraphRedex helps to understand the semantics of two published works. Exploration of the semantics with GraphRedex unveiled an issue in one of the implementations of these works, which the author confirmed.

A process calculus BigrTiMo of mobile systemsand its formal semantics

Abstract In this paper, we present a process calculus called BigrTiMo that combines the rTiMo calculus and the Bigraph model. BigrTiMo calculus is capable of specifying a rich variety of properties for structure-aware mobile systems. Compared with rTiMo, our BigrTiMo calculus can specify not only time, mobility and local communication, but also remote communication. We then investigate the operational semantics of the BigrTiMo calculus and develop an executable formal specification of our BigrTiMo calculus in a declarative language called Maude. In addition, we verify safety properties and liveness properties of the mobile systems described by BigrTiMo using state exploration and LTL model checking in Maude. Based on Hoare and He's Unifying Theories of Programming (UTP), we study the semantic foundation of this highly expressive modelling language and propose a denotational semantic model and a set of algebraic laws for it. The semantic model in this paper covers time, location, communication and global shared variable at the same time. We also demonstrate the proofs of some algebraic laws based on our denotational semantics. Moreover, we explore how the algebraic semantics relates with the operational semantics and denotational semantics, which is conducted by the study of deriving the operational semantics and denotational semantics from algebraic semantics. We prove the equivalence between the derived transition system (e.g., the operational semantics) and the derivation strategy, which indicates that the operational semantics is sound and complete.

Operational Semantics with Hierarchical Abstract Syntax Graphs

This is a motivating tutorial introduction to a semantic analysis of programming languages using a graphical language as the representation of terms, and graph rewriting as a representation of reduction rules. We show how the graphical language automatically incorporates desirable features, such as alpha-equivalence and how it can describe pure computation, imperative store, and control features in a uniform framework. The graph semantics combines some of the best features of structural operational semantics and abstract machines, while offering powerful new methods for reasoning about contextual equivalence. All technical details are available in an extended technical report by Muroya and the author and in Muroya's doctoral dissertation.

Categorical semantics of a simple differential programming language

With the increased interest in machine learning, and deep learning in particular, the use of automatic differentiation has become more wide-spread in computation. There have been two recent developments to provide the theoretical support for this types of structure. One approach, due to Abadi and Plotkin, provides a simple differential programming language. Another approach is the notion of a reverse differential category. In the present paper we bring these two approaches together. In particular, we show how an extension of reverse derivative categories models Abadi and Plotkin's language, and describe how this categorical model allows one to consider potential improvements to the operational semantics of the language.

C floating point proofs layered with VST and Flocq

We demonstrate tools and methods for proofs about the correctness and numerical accuracy of C programs. The tools are foundational, in that they are connected to formal semantic specifications of the C operational semantics and of the IEEE 754 floating-point format. The tools are modular, in that the reasoning about C programming can be done quite separately from the reasoning about numerical correctness and numerical accuracy. The tools are general, in that they accommodate almost the entire C language (with pointer data structures, function pointers, control flow, etc.) and applied mathematics (reasoned about in a general-purpose logic and proof assistant with substantial libraries for mathematical reasoning). We demonstrate on a simple Newton's-method square root function.

Symbolic execution formally explained

In this paper, we provide a formal explanation of symbolic execution in terms of a symbolic transition system and prove its correctness and completeness with respect to an operational semantics which models the execution on concrete values.We first introduce a formalmodel for a basic programming languagewith a statically fixed number of programming variables. This model is extended to a programming language with recursive procedures which are called by a call-by-value parameter mechanism. Finally, we present a more general formal framework for proving the soundness and completeness of the symbolic execution of a basic object-oriented language which features dynamically allocated variables.

Verification of Program Transformations with Inductive Refinement Types

High-level transformation languages like Rascal include expressive features for manipulating large abstract syntax trees: first-class traversals, expressive pattern matching, backtracking, and generalized iterators. We present the design and implementation of an abstract interpretation tool, Rabit, for verifying inductive type and shape properties for transformations written in such languages. We describe how to perform abstract interpretation based on operational semantics, specifically focusing on the challenges arising when analyzing the expressive traversals and pattern matching. Finally, we evaluate Rabit on a series of transformations (normalization, desugaring, refactoring, code generators, type inference, etc.) showing that we can effectively verify stated properties.

On checking equivalence of simulation scripts

To support Model Based Design of Cyber-Physical Systems (CPSs) many simulation based approaches to System Level Formal Verification (SLFV) have been devised. Basically, these are Bounded Model Checking approaches (since simulation horizon is of course bounded) relying on simulators to compute the system dynamics and thereby verify the given system properties. The main obstacle to simulation based SLFV is the large number of simulation scenarios to be considered and thus the huge amount of simulation time needed to complete the verification task. To save on computation time, simulation based SLFV approaches exploit the capability of simulators to save and restore simulation states. Essentially, such a time saving is obtained by optimising the simulation script defining the simulation activity needed to carry out the verification task. Although such approaches aim to (bounded) formal verification, as a matter of fact, the proof of correctness of the methods to optimise simulation scripts basically relies on an intuitive semantics for simulation scripting languages. This hampers the possibility of formally showing that the optimisations introduced to speed up the simulation activity do not actually omit checking of relevant behaviours for the system under verification. The aim of this paper is to fill the above gap by presenting an operational semantics for simulation scripting languages and by proving soundness and completeness properties for it. This, in turn, enables formal proofs of equivalence between unoptimised and optimised simulation scripts.

Compatibility checking for asynchronously communicating software

• Inter-operability of distributed systems. • Asynchronous operational semantics using FIFO buffers. • Decidability of synchronizability and wellformedness. • Refinement based proofs and model checking of distributed systems' compatibility. • Tool support. Compatibility is a crucial problem that is encountered while constructing new software by reusing and composing existing components. A set of software components is called compatible if their composition preserves certain properties, such as deadlock freedom. However, checking compatibility for systems communicating asynchronously is an undecidable problem, and asynchronous communication is a common interaction mechanism used in building software systems. A typical approach in analyzing such systems is to bound the state space. In this article, we propose a different approach and do not impose any bounds on the number of participants or the sizes of the message buffers. Instead, we present a sufficient condition for checking compatibility of a set of asynchronously communicating components. Our approach relies on the synchronizability property which identifies systems for which interaction behavior remains the same when asynchronous communication is replaced with synchronous communication. Using the synchronizability property, we can check the compatibility of systems with unbounded message buffers by analyzing only a finite part of their behavior. We have implemented a prototype tool to automate our approach and we have applied it to many examples.

A computational interpretation of compact closed categories: reversible programming with negative and fractional types

Compact closed categories include objects representing higher-order functions and are well-established as models of linear logic, concurrency, and quantum computing. We show that it is possible to construct such compact closed categories for conventional sum and product types by defining a dual to sum types, a negative type, and a dual to product types, a fractional type. Inspired by the categorical semantics, we define a sound operational semantics for negative and fractional types in which a negative type represents a computational effect that ``reverses execution flow'' and a fractional type represents a computational effect that ``garbage collects'' particular values or throws exceptions. Specifically, we extend a first-order reversible language of type isomorphisms with negative and fractional types, specify an operational semantics for each extension, and prove that each extension forms a compact closed category. We furthermore show that both operational semantics can be merged using the standard combination of backtracking and exceptions resulting in a smooth interoperability of negative and fractional types. We illustrate the expressiveness of this combination by writing a reversible SAT solver that uses backtracking search along freshly allocated and de-allocated locations. The operational semantics, most of its meta-theoretic properties, and all examples are formalized in a supplementary Agda package.

A graded dependent type system with a usage-aware semantics

Graded Type Theory provides a mechanism to track and reason about resource usage in type systems. In this paper, we develop GraD, a novel version of such a graded dependent type system that includes functions, tensor products, additive sums, and a unit type. Since standard operational semantics is resource-agnostic, we develop a heap-based operational semantics and prove a soundness theorem that shows correct accounting of resource usage. Several useful properties, including the standard type soundness theorem, non-interference of irrelevant resources in computation and single pointer property for linear resources, can be derived from this theorem. We hope that our work will provide a base for integrating linearity, irrelevance and dependent types in practical programming languages like Haskell.

Abstracting gradual typing moving forward: precise and space-efficient

Abstracting Gradual Typing (AGT) is a systematic approach to designing gradually-typed languages. Languages developed using AGT automatically satisfy the formal semantic criteria for gradual languages identified by Siek et al. Nonetheless, vanilla AGT semantics can still have important shortcomings. First, a gradual language's runtime checks should preserve the space-efficiency guarantees inherent to the underlying static and dynamic languages. To the contrary, the default operational semantics of AGT break proper tail calls. Second, a gradual language's runtime checks should enforce basic modular type-based invariants expected from the static type discipline. To the contrary, the default operational semantics of AGT may fail to enforce some invariants in surprising ways. We demonstrate this in the GTFL ≲ language of Garcia et al. This paper addresses both problems at once by refining the theory underlying AGT's dynamic checks. Garcia et al. observe that AGT involves two abstractions of static types: one for the static semantics and one for the dynamic semantics. We recast the latter as an abstract interpretation of subtyping itself, while gradual types still abstract static types. Then we show how forward-completeness (Giacobazzi and Quintarelli) is key to supporting both space-efficient execution and reliable runtime type enforcement.