AN OPERATIONAL SEMANTICS FOR THE PARALLEL LANGUAGE EDEN

2002 ◽  
Vol 12 (02) ◽  
pp. 211-228 ◽  
Author(s):  
MERCEDES HIDALGO-HERRERO ◽  
YOLANDA ORTEGA-MALLÉN
Keyword(s):  
Operational Semantics ◽  
Transition System ◽  
Lazy Evaluation ◽  
Parallel Language ◽  
Parallel Processes ◽  
System A ◽  
Independent Evaluation ◽  
Level Transition ◽  
Concurrent Algorithms ◽  
Main Thread

The functional parallel language Eden — suitable for the description of parallel and concurrent algorithms in a distributed setting — is an extension of Haskell with a set of coordination features. In this paper we present a formal operational semantics for the kernel of Eden, or more precisely, for a λ-calculus widened with explicit parallelism and potentially infinite communication channels. Eden overrides the lazy nature of Haskell on behalf of parallelism. This interplay between laziness and eagerness is accurately described by the semantics proposed here, which is based on Launchbury's natural semantics for lazy evaluation, and is expressed through a two-level transition system: a lower level for the local and independent evaluation of each process, and an upper one for the coordination between all the parallel processes in the system. As processes are created either under demand or in a speculative way, different scheduling strategies are possible — ranging from a minimal one that only allows the main thread to evolve, to a maximal one that evolves in parallel every active binding.

An operational semantics for parallel lazy evaluation

2000 ◽  
Vol 35 (9) ◽  
pp. 162-173 ◽  
Author(s):  
Clem Baker-Finch ◽  
David J. King ◽  
Phil Trinder
Keyword(s):  
Operational Semantics ◽  
Lazy Evaluation

scholarly journals From Interpreter to Logic Engine by Defunctionalization

2003 ◽  
Vol 10 (25) ◽  
Author(s):  
Dariusz Biernacki ◽  
Olivier Danvy
Keyword(s):  
Logic Programming ◽  
Programming Language ◽  
Operational Semantics ◽  
Lambda Calculus ◽  
Transition System ◽  
Abstract Machine ◽  
Logic Programming Language ◽  
Delimited Continuations ◽  
Simple Logic ◽  
Control Operators

Starting from a continuation-based interpreter for a simple logic programming language, propositional Prolog with cut, we derive the corresponding logic engine in the form of an abstract machine. The derivation originates in previous work (our article at PPDP 2003) where it was applied to the lambda-calculus. The key transformation here is Reynolds's defunctionalization that transforms a tail-recursive, continuation-passing interpreter into a transition system, i.e., an abstract machine. Similar denotational and operational semantics were studied by de Bruin and de Vink in previous work (their article at TAPSOFT 1989), and we compare their study with our derivation. Additionally, we present a direct-style interpreter of propositional Prolog expressed with control operators for delimited continuations.<br /><br />Superseded by BRICS-RS-04-5.

scholarly journals Constraint functional logic programming over finite domains

2007 ◽  
Vol 7 (5) ◽  
pp. 537-582 ◽  
Author(s):  
ANTONIO J. FERNÁNDEZ ◽  
TERESA HORTALÁ-GONZÁLEZ ◽  
FERNANDO SÁENZ-PÉREZ ◽  
RAFAEL DEL VADO-VÍRSEDA
Keyword(s):  
Logic Programming ◽  
Operational Semantics ◽  
Point Of View ◽  
Finite Domain ◽  
Lazy Evaluation ◽  
Functional Logic Programming ◽  
Functional Logic ◽  
Finite Domains ◽  
Higher Order Functions ◽  
Domain Constraints

AbstractIn this paper, we present our proposal to Constraint Functional Logic Programming over Finite Domains (CFLP($\fd$)) with a lazy functional logic programming language which seamlessly embodies finite domain ($\fd$) constraints. This proposal increases the expressiveness and power of constraint logic programming over finite domains (CLP($\fd$)) by combining functional and relational notation, curried expressions, higher-order functions, patterns, partial applications, non-determinism, lazy evaluation, logical variables, types, domain variables, constraint composition, and finite domain constraints. We describe the syntax of the language, its type discipline, and its declarative and operational semantics. We also describe\toy(fd)$, an implementation forCFLP($\fd$), and a comparison of our approach with respect toCLP($\fd$) from a programming point of view, showing the new features we introduce. And, finally, we show a performance analysis which demonstrates that our implementation is competitive with respect to existingCLP($\fd$) systems and that clearly outperforms the closer approach toCFLP($\fd$).

MODEL CHECKING OF COMPONENT BASED SOFTWARE USING COMPOSITIONAL REDUCTIONS

2008 ◽  
Vol 18 (05) ◽  
pp. 683-712 ◽  
Author(s):  
MOHAMMAD IZADI ◽  
ALI MOVAGHAR
Keyword(s):  
Model Checking ◽  
Composition Operators ◽  
Linear Time ◽  
Operational Semantics ◽  
Computing System ◽  
Transition System ◽  
Compositional Model ◽  
Temporal Properties ◽  
Labeled Transition System ◽  
Constraint Automata

A component-based computing system consists of two main parts: a set of components and a coordination subsystem. Reo is an exogenous coordination language for compositional construction of the coordination subsystem. Constraint automaton has been defined as the operational semantics of Reo. The main goal of this paper is to prepare a model checking method for verifying linear time temporal properties of component-based systems whose coordinating subsystems are modeled by Reo and components are modeled by labeled transition systems. For this purpose, we introduce modified definitions of constraint automata and their composition operators by which, every constraint automaton can be considered as a labeled transition system and each labeled transition system can be translated into a constraint automaton. We show that failure-based equivalences CFFD and NDFD are congruences with respect to the composition operators of constraint automata. Also we present a method for compositional model checking of component-based systems using these equivalences for reducing the sizes of constraint automata models.

scholarly journals A Semantic Theory for Value-Passing Processes Based on the Late Approach

2003 ◽  
Vol 10 (15) ◽  
Author(s):  
Anna Ingólfsdóttir
Keyword(s):  
General Class ◽  
Operational Semantics ◽  
Denotational Semantics ◽  
Semantic Theory ◽  
Transition System ◽  
Semantic Approach ◽  
Proof Systems ◽  
A Value ◽  
Concrete Language ◽  
Labelled Transition System

A general class of languages for value-passing calculi based on the late semantic approach is defined and a concrete instantiation of the general syntax is given. This is a modification of the standard CCS according to the late approach. Three kinds of semantics are given for this language. First a Plotkin style operational semantics by means of an applicative labelled transition system is introduced. This is a modification of the standard labelled transition system that caters for value-passing according to the late approach. As an abstraction, late bisimulation preorder is given. Then a general class of denotational models for the late semantics is defined. A denotational model for the concrete language is given as an instantiation of the general class. Two equationally based proof systems are defined. The first one, which is value-finitary, i. e. only reasons about a finite number of values at each time, is shown to be sound and complete with respect to this model. The second proof system, a value-infinitary one, is shown to be sound with respect to the model, whereas the completeness is proven later. The operational and the denotational semantics are compared and it is shown that the bisimulation preorder is finer than the preorder induced by the denotational model. We also show that in general the omega-bisimulation preorder is strictly included in the model induced preorder. Finally a value-finitary version of the bisimulation preorder is defined and the full abstractness of the denotational model with respect to it is shown. It is also shown that for CCS_L the omega -bisimulation preorder coincides with the preorder induced by the model. From this we can conclude that if we allow for parameterized recursion in our language, we may express processes which coincide in any algebraic domain but are distinguished by the omega-bisimulation. This shows that if we extend CCS_L in this way we obtain a strictly more expressive language.

scholarly journals From Interpreter to Logic Engine by Defunctionalization

2004 ◽  
Vol 11 (5) ◽  
Author(s):  
Dariusz Biernacki ◽  
Olivier Danvy
Keyword(s):  
Logic Programming ◽  
Programming Language ◽  
Operational Semantics ◽  
Lambda Calculus ◽  
Transition System ◽  
Abstract Machine ◽  
Logic Programming Language ◽  
Delimited Continuations ◽  
Simple Logic ◽  
Control Operators

Starting from a continuation-based interpreter for a simple logic programming language, propositional Prolog with cut, we derive the corresponding logic engine in the form of an abstract machine. The derivation originates in previous work (our article at PPDP 2003) where it was applied to the lambda-calculus. The key transformation here is Reynolds's defunctionalization that transforms a tail-recursive, continuation-passing interpreter into a transition system, i.e., an abstract machine. Similar denotational and operational semantics were studied by de Bruin and de Vink (their article at TAPSOFT 1989), and we compare their study with our derivation. Additionally, we present a direct-style interpreter of propositional Prolog expressed with control operators for delimited continuations.

scholarly journals CCS, Locations and Asynchronous Transition Systems

1992 ◽  
Vol 21 (395) ◽  
Author(s):  
Madhavan Mukund ◽  
Mogens Nielsen
Keyword(s):  
Operational Semantics ◽  
Transition System ◽  
Additional Property ◽  
Close Correspondence ◽  
Transition Systems ◽  
Natural Way

<p>Our aim is to provide a simple non-interleaved operational semantics for CCS in terms of a model that is easy to understand - asynchronous transition systems. Our approach is guided by the requirement that the semantics should identify the concurrency present in the system in a natural way, in terms of events occurring at independent locations in the system.</p><p>We extend the standard interleaving transition system for CCS by introducing labels on the transitions with information about the locations of events. We then show that the resulting transition system is an asynchronous transition system which has the additional property of being <em>elementary</em>, which means that it can also be represented by a 1-safe net. We establish a close correspondence between our semantics and other approaches in terms of <em>foldings</em>.</p><p>We also introduce a notion of bisimulation on asynchronous transition systems which preserves independence. We conjecture that the induced equivalence on CCS processes coincides with the notion of <em>location equiualence</em> proposed by Boudol et al.</p>

scholarly journals A Scientific Calculator for Exact Real Number Computation Based on LRT, GMP and FC++

2012 ◽  
Vol 22 ◽  
pp. 35-41
Author(s):  
Alejandra Lucatero ◽  
J. Raymundo Marcial-Romero ◽  
J. A. Hernández
Keyword(s):  
Real Number ◽  
Programming Language ◽  
Functional Programming ◽  
Operational Semantics ◽  
Trigonometric Functions ◽  
Lazy Evaluation ◽  
Evaluation Mechanism ◽  
The One ◽  
Exact Real Number Computation ◽  
Scientific Calculator

Language for Redundant Test (LRT) is a programming language for exact real number computation. Its lazy evaluation mechanism (also called call-by-need) and its infinite list requirement, make the language appropriate to be implemented in a functional programming language such as Haskell. However, a direction translation of the operational semantics of LRT into Haskell as well as the algorithms to implement basic operations (addition subtraction, multiplication, division) and trigonometric functions (sin, cosine, tangent, etc.) makes the resulting scientific calculator time consuming and so inefficient. In this paper, we present an alternative implementation of the scientific calculator using FC++ and GMP. FC++ is a functional C++ library while GMP is a GNU multiple presicion library. We show that a direct translation of LRT in FC++ results in a faster scientific calculator than the one presented in Haskell.

scholarly journals Symbolic execution formally explained

2021 ◽  
Author(s):  
Frank S. de Boer ◽  
Marcello Bonsangue
Keyword(s):  
Programming Language ◽  
Symbolic Execution ◽  
Operational Semantics ◽  
Object Oriented ◽  
Fixed Number ◽  
Transition System ◽  
Basic Object ◽  
Formal Framework ◽  
Recursive Procedures ◽  
Soundness And Completeness

AbstractIn 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.

Sign in / Sign up

Export Citation Format

Share Document