Operational Semantics Research Papers - Academia.edu (original) (raw)

2025

Abstract--In this paper we present a model able to serve in validating either functional or non-functional properties of the hard real time systems. We firstly introduce the timed SystemC waiting state automata (TWSA) that will serve in... more

2025, Logic Programming and Knowledge Representation

Recently the field of theory update has seen some improvement, in what concerns model updating, by allowing updates to be specified by so-called revision programs. The updating of theory models is governed by their update rules and also by inertia applied to those literals not directly affected by the update program. Though this is important, it remains necessary to tackle as well the updating of programs specifying theories. Some results have been obtained on the issue of updating a logic program which encodes a set of models, to obtain a new program whose models are the desired updates of the initial models. But here the program only plays the rôle of a means to encode the models. A logic program encodes much more than a set of models: it encodes knowledge in the form of the relationships between the elements of those models. In this paper we advocate that the principle of inertia is advantageously applied to the rules of the initial program rather than to the individual literals in a model. Indeed, we show how this concept of program update generalizes model or interpretation updates. Furthermore, it allows us to conceive what it is to update one program by another, a crucial notion for opening up a whole new range of applications concerning the evolution of knowledge bases. We will consider the updating of normal programs as well as these extended with explicit negation, under the stable semantics.

2025, Springer eBooks

In this paper we are interested in general properties of classes of transition system specifications in Plotkin style. The discussion takes place in a setting of labelled transition systems. The states of the transition systems are terms generated by a single sorted signature and the transitions between states are defined by conditional rules over tne syntax. It is argued that in this setting it is natural to require that strong bisimulation equivalence be a congruence on the states of the transition systems. A general format, called the 1xfi/1yxt format, is presented for the rules in a transition system specification, such that bisimulation is always a congruence when all the rules fit this format. With a series of examples it is demonstrated that the t.i:fi/1yxt format cannot be generalized in any obvious way. Another series of examples illustrates the usefulness of our congruence theorem. Briefly we touch upon the issue of modularity of transition system specifications. It is argued that certain pathological tyft/tyxt rules (the ones which are not pure) can be disqualified because they behave badly with respect to modularization. Next we address the issue of full abstraction. We characterize the completed trace congruence induced by the operators in pure tyft/tyxt format as 2-nested simulation equivalence. The pure tyft/tyxt format includes the format given by de Simone ( Theoret. Comput. Sci. 37, 245-267 (1985)) but is incomparable to the GSOS format of Bloom, Istrail, and Meyer (in "Conference Record of the 15th Annual Symposium on Principles of Programming Languages, San Diego, California, 1988," pp. 229-239). However, it turns out that 2-nested simulation equivalence strictly refines the completed trace congruence induced by the GSOS format.

2025

In this paper we postulate OCLh as a prototype for future planning domain modelling languages which are foundationally sound, but offer features that are attractive and support- ive to knowledge engineers. The novel contributions of this paper is that it (a) describes a truth ctiterion for OCLh and details a proof that the criterion is sufficient for ensuring nec- essary

2025

This chapter looks at these issues in process algebras. As a canonical example we look at CSP, but we also discuss CCS and LOTOS. The link to the semantics is made to Chap. 1 as well as elements of Chap. 5. Process algebras describe a system in terms of interacting components which evolve concurrently. The components are called processes. The use of the word algebra refers to the fact that these languages are often equipped with a rich algebraic theory in terms of laws giving equivalence of processes. The alternative term of "process calculi" is sometimes used. CSP (for Communicating Sequential Processes) describes a system as a collection of interacting communicating components running concurrently. The components are called processes, and the interaction between them is in terms of the synchronisation on events. We will think of a process as a self-contained component with an interface, through which it interacts with the environment, and the interface is described as a set of events. Events are instantaneous and atomic, just as the actions in a labelled transition system. Notation: We will use the following notation. Σ is the set of all possible events. will be a termination event, not in Σ. We define the set Σ to be Σ ∪ { } (and similarly for A ). TRACE is the set of all traces over Σ . As usual traces(P) is the set of all finite traces of a process P. Processes are described by guarded equations as in the following small example (c.f. Fig. 1.1 in Chap. 1): V M = pound →((coffee_button → coffee → stop) (tea_button → tea → stop))

2025, Theoretical Computer Science

This volume contains both the ÿnal versions of a selection of papers presented at the First International Workshop on Coalgebraic Methods in Computer Science (CMCS), which was held in Lisbon, March 28-29, 1998, as a satellite event to ETAPS'98, and a number of invited papers. The proceedings of CMCS'98 have appeared as Vol. 11 of Elsevier's Electronic Notes in Theoretical Computer Science. The workshop, which was the ÿrst ever dedicated to the subject of coalgebra, has beeen organized by the four guest editors of the present volume. It was well attended (approximately 70 participants), and has brought together researchers from both mathematics and computer science, some of whom had until then been working on the subject in isolation. At the time of this writing, a second and a third similar workshop have already taken place:

2025, IEEE Transactions on Automatic Control

2025, ACM SIGPLAN Notices

This paper describes alternative memory semantics for Java programs using an enriched version of the Commit/Reconcile/Fence (CRF) memory model [16]. It outlines a set of reasonable practices for safe multithreaded programming in Java. Our semantics allow a number of optimizations such as load reordering that are currently prohibited. Simple thread-local algebraic rules express the effects of optimizations at the source or bytecode level. The rules focus on reordering source-level operations; they yield a simple dependency analysis algorithm for Java. An instruction-by-instruction translation of Java memory operations into CRF operations captures thread interactions precisely. The fine-grained synchronization of CRF means the algebraic rules are easily derived from the translation. CRF can be mapped directly to a modern architecture, and is thus a suitable target for optimizing memory coherence during code generation.

2025, Electronic Notes in Theoretical Computer Science

λS extends the λ-calculus with recursive bindings, barriers, and updatable memory cells with synchronized operations. The calculus can express both deterministic and nondeterministic computations. It is designed to be useful for reasoning about compiler optimizations and thus allows reductions anywhere, even inside λ's. Despite the presence of side effects, the calculus retains fine-grained, implicit parallelism and non-strict functions: there is no global, sequentializing store. Barriers, for sequencing, capture a robust notion of termination. Although λS was developed as a foundation for the parallel functional languages pH and Id, we believe that barriers give it wider applicability — to sequential, explicitly parallel and concurrent languages. In this paper we describe the λS-calculus and its properties, based on a notion of observable information in a term. We also describe reduction strategies to compute maximal observable information even in the presence of unbounded nond...

2025, arXiv (Cornell University)

We express Brewka's prioritised default logic (PDL) as argumentation using ASPIC + . By representing PDL as argumentation and designing an argument preference relation that takes the argument structure into account, we prove that the conclusions of the justified arguments correspond to the PDL extensions. We will first assume that the default priority is total, and then generalise to the case where it is a partial order. This provides a characterisation of non-monotonic inference in PDL as an exchange of argument and counter-argument, providing a basis for distributed non-monotonic reasoning in the form of dialogue. 1

2025, arXiv (Cornell University)

Statechart is a visual modelling language for systems. In this paper, we extend our earlier work on modular statecharts with local variables and present an updated operational semantics for statecharts with concurrency. Our variant of the statechart has local variables, which interact significantly with the remainder of the language semantics. Our semantics does not allow transition conflicts in simulations and is stricter than most other available semantics of statecharts in that sense. It allows arbitrary interleaving of concurrently executing action code, which allows more precise modelling of systems and upstream analysis of the same. We present the operational semantics in the form of the simulation algorithm. We also establish the criteria based on our semantics for defining conflicting transitions and valid simulations. Our semantics is executable and can be used to simulate statechart models and verify their correctness. We present a preliminary setup to carry out fuzz testing of Statechart models, an idea that does not seem to have a precedent in literature. We have used our simulator in conjunction with a well-known fuzzer to do fuzz testing of statechart models of non-trivial sizes and have found issues in them that would have been hard to find through inspection.

2025, Springer eBooks

In recent years many techniques have been developed for automatically verifying concurrent systems and most of them are based on a representation of the concurrent system by means of a transition system. State explosion is one of the most serious problems of this approach: in fact often the prohibitive number of states renders the veri cation ine cient and, in some cases, impossible. We propose an approach to the reduction of the state space of the transition system corresponding to a CCS process, which takes into account the deadlock freeness property. The reduced transition system is generated by means of a non-standard operational semantics containing a set of rules which are, in some sense, an abstraction, preserving deadlock freeness, of the inference rules of the standard semantics.

2025, Information Processing Letters

In this paper we show how the Cousots' approach to abstract interpretation can be easily and profitably applied to the analysis of concurrent calculi. Actually, when dealing with concurrent processes, a number of interesting properties are independent from the computed values, while they strongly depend on the behavior of processes in terms of performed sequences of actions. In this paper abstract interpretation is applied to the analysis of such a behavior. For this reason, we refer to a quite basic concurrent language: Calculus of Communicating Systems (CCS) without values. The analysis we want to perform can be called interesting actions analysis: the behavior of a process P is observed in an "abstract" way, disregarding all the non-interesting actions. This abstraction can be used as a method for efficiently verifying properties of CCS processes. The abstract semantics we present for such language is able to build a reduced transition system which maintains, with respect to the set of interesting actions, the behavior of the original CCS process. We show how the use of our abstract semantics leads to a reduced transition system on which the properties can be equivalently checked. We consider, as the meaning of CCS processes, the well-known trace semantics, which describes the sequences of actions which can be performed by a process. The interesting actions analysis is seen as an abstraction of such a concrete semantics.

2025, Information Sciences

In model checking environments, system requirements are usually expressed by means of temporal logic formulas. We propose a user-friendly interface (UFI) with the aim of simplifying the writing of concurrent system properties. The tool is endowed with a graphical interface that supplies a set of patterns from the natural language; the defined patterns constitute a logic (UFL) that is adequate to express the classes of properties usually checked on actual systems. Moreover, UFI is integrated with the CWB-NC tool-kit which is a verification environment based on process algebras and the mu-calculus temporal logic; UFI supports the automatic translation of UFL formulas into mu-calculus formulas and save the translation in the format required by the CWB-NC. Nevertheless, UFI is a flexible tool that can be easily integrated with other environments.

2025, Springer eBooks

In model checking for temporal logic, the correctness of a (concurrent) system with respect to a desired behavior is verified by checking whether a structure that models the system satisfies a formula describing the behaviour. Most existing verification techniques, and in particular those defined for concurrent calculi like as CCS, are based on a representation of the concurrent system by means of a labelled transition system. In this approach to verification, state explosion is one of the most serious problems. In this paper we present a new temporal logic, the selective mu-calculus, with the property that only the actions occurring in a formula are relevant to check the formula itself. We prove that the selective mu-calculus is as powerful as the mu-calculus. We define the notion of p-bisimulation between transition systems: given a set of actions p, a transition system p-bisimulates another one if they have the same behaviour with respect to the actions in p. We prove that, if two transition systems are p-equivalent, they preserve all the selective mu-calculus formulae with occurring actions in p. Consequently, a formula with occurring actions p can be more efficiently checked on a transition system p-equivalent to the standard one, but smaller than it.

2025, Electronic Notes in Theoretical Computer Science

Java is largely used to develop distributed and concurrent systems, but testing multithreaded systems cannot guarantee the quality of the software; in contrast, verification techniques give us a higher confidence about the system and, among these, model checking methods automatically establish properties of complex systems. Such techniques are usually applied to specification languages, and several environments exist to verify temporal properties of concurrent specifications. In this paper we present an attempt to apply model checking techniques for verifying a subset of multithreaded Java programs. In particular, we use a tool based on the selective mu-calculus logic to check systems described through the CCS specification language.

2025, Formal Methods in System Design

Verification of a concurrent system can be accomplished by model checking the properties on a structure representing the system; this structure is, in general, a transition system which contains a prohibitive number of states. In this paper, we apply a method to reduce the state explosion problem by pointing out the events of the system to be ignored on the basis of the property to be verified. We evaluate the method by means of a real application used as a case study: the system is specified by a CCS program, then the program is reduced by means of syntactic rules; afterwards, the corresponding transition system is built by means of a non-standard operational semantics, which performs further reductions during the construction. Prototype tools perform both kinds of reductions; finally the required properties are checked by means of the model checkers of the CWB-NC.

2025, Science of Computer Programming

Software engineering research is driven by the aim of making software development more dynamic, flexible and evolvable. Nowadays the emphasis is on the evolution of pre-existing sub-systems and component and service-based development, where often only a part of the system is totally under control of the designer, most components being remotely operated by external vendors. In this context, we tackle the following problem: given the formal specification of the (incomplete) system, say it p, already built, how to characterize collaborators of p to be selected, based on a given communication interface L, so that a given property ϕ is satisfied. Using properties described by temporal logic formulae and systems by CCS processes, if ϕ is the formula to be satisfied by the complete system, an efficient and automatic procedure is defined to identify a formula ψ such that, for each existing process q satisfying ψ, the process (p | q) \ L satisfies ϕ. Important features of this result are simplicity of the derived property ψ, compared to the original one, and scalability of the verification process. Such characteristics are necessary for applying the method to both incremental design and system evolution scenarios where p is already in place, and one needs to understand the specification of the functionality of the new component that should correctly interact with p. Indeed, in general, finding a suitable partner for p is easier than finding a complete system satisfying the global property. Moreover, in this paper it is shown how ψ can be used also to select a set of possible candidate processes q through a property-directed and structural heuristic. From the verification point of view, the description of the lacking component through a logic formula guarantees correctness of the integration with p of any process that exhibits a behaviour compliant with the inferred formula.

2025, Mathematics in Computer Science

Is it possible to symbolically express and analyse an individualbased model of disease spread, including realistic population dynamics? This problem is addressed through the use of process algebra and a novel method for transforming process algebra into Mean Field Equations. A number of stochastic models of population growth are presented, exploring different representations based on alternative views of individual behaviour. The overall population dynamics in terms of mean field equations are derived using a formal and rigorous rewriting based method. These equations are easily compared with the traditionally used deterministic Ordinary Differential Equation models and allow evaluation of those ODE models, challenging their assumptions about system dynamics. The utility of our approach for epidemiology is confirmed by constructing a model combining population growth with disease spread and fitting it to data on HIV in the UK population.

2025, Theoretical Computer Science

A new semantics in terms of Mean Field Equations is presented for WSCCS (Weighted Synchronous Calculus of Communicating Systems). The semantics captures the average behaviour of the system over time, but without computing the entire state space, therefore avoiding the state space explosion problem. This allows easy investigation of models with large numbers of components. The new semantics is shown to be equivalent to the standard Discrete Time Markov Chain semantics of WSCCS as the number of processes tends to infinity. The method of deriving the semantics is illustrated with examples drawn from biology and from computing.

2025, International Conference on Computer Aided Design

The time separation of events (TSE) problem is that of finding the maximum and minimum separation between the times of occurrence of two events in a concurrent system. It has applications in the performance analysis, optimization and verification of concurrent digital systems. This paper introduces an efficient polynomial-time algorithm to give exact bounds on TSE's for choice-free concurrent systems, whose operational semantics obey the max-causality rule. A choicefree concurrent system is modeled as a strongly-connected marked graph, where delays on operations are modeled as bounded intervals with unspecified distributions. While previous approaches handle acyclic systems only, or else require graph unfolding until a steady-state behavior is reached, the proposed approach directly identifies and evaluates the asymptotic steady-state behavior of a cyclic system via a graph-theoretical approach. As a result, the method has significantly lower computational complexity than previously-proposed solutions. A prototype CAD tool has been developed to demonstrate the feasibility and efficacy of our method. A set of experiments have been performed on the tool as well as two existing tools, with noticeable improvement on runtime and accuracy for several examples. This paper addresses the problem of finding the maximum and minimum time separation of events (TSE) in concurrent systems. A concurrent system is considered as a set of interacting processes which communicate through channels. When a process initiates a communication with one or more other processes, it waits for all parties to respond before it proceeds. Such operating semantics is said to obey the max-causality rule, or to operate under the max timing constraint. This model can be applied to problems in a wide range of domains. A "process" can correspond to the transition of a signal at the circuit level, or to a partition of functional units at the system level. Several delay models have been used in modelling these systems. A "stochastic model" is often used for the performance analysis of these systems , . However, for verification, a "bounded-delay" model, where the computation time of each process is assumed to be bounded below (min) and above (max) by non-negative real numbers, with no distribution specified, is much more useful. In the special case where the upper and lower bounds of the computation time are identical, a "fixed-delay" model is said to be used. This paper targets concurrent systems under a bounded-delay model. To make the problem amenable for analysis, the system is assumed to be decision-free; such systems can be modeled by marked graphs , which are commonly used to capture concurrent behavior. The TSE problem for bounded-delay systems has applications to performance analysis, optimization of verification of concurrent systems. In this case, while it is generally not possible to provide accurate average case performance metrics, since no delay distribution is given, one can usefully predict best case and worst case performance metrics, such as system throughput. For the restricted case of fixed-delay systems, TSE also becomes a performance measure of the system, as in this case the distribution of the delay is trivially known (i.e. exactly one delay value per event in the system).

2025

My contribution, described in this thesis, is a theory that is meant to assist in the construction of complex software systems. I propose a notion of structure that is independent of language, formalism, or problem domain. I call this new abstraction a kind, and its related formal system, kind theory. I define a type system that models the structural aspects of kind theory. I also define an algebra that models this type system and provides a logic in which one can specify and execute computations. A reflective definition of kind theory is reviewed. This reflective specification depends upon a basic ontology for mathematics. By specifying the theory in itself, I provide an example of how one can use kind theory to reason about reuse in general formal systems. I provide examples of the use of kind theory in reasoning about software constructs in several domains of software engineering. I also discuss a set of software tools that I have constructed that realize or use kind theory. A lo...

2025, Lecture Notes in Computer Science

Flow logic is an approach to static analysis that separates the specification of when an analysis estimate is acceptable for a program from the actual computation of the analysis information. It allows one not only to combine a variety of programming paradigms but also to link up with state-of-the-art developments in classical approaches to static analysis, in particular data flow analysis, constraint-based analysis and abstract interpretation. This paper gives a tutorial on flow logic and explains the underlying methodology; the multi-paradigmatic approach is illustrated by a number of examples including functional, imperative, object-oriented and concurrent constructs.

2025

In this article we propose a Probabilistic Situation Calculus logical language to represent and reason with knowledge about dynamical worlds in which actions have uncertain effects. Two essential tasks are addressed when reasoning about change in worlds: Probabilistic Temporal Projection and Probabilistic Belief Update. Uncertain effects are modeled by dividing an action into two subparts: a deterministic input (agent produced) and a probabilistic reaction (nature produced). The probability distributions of the reactions are assumed to be known. Our logical language is an extension to Situation Calculae in the style proposed by Raymond Reiter. There are three aspects to this work. First, we extend the language to accommodate terms dealing with belief and probability. Second, we provide a operational semantics based on Randomly Timed Automata. Finally, we develop Monte-Carlo algorithms to efficiently interpret the probability and belief terms. With the framework proposed we discuss how to develop a reasoning system in Mathematica capable of performing temporal projection and belief update in the Probabilistic Situation Calculus. Finally, we present a sound basis to set rewards and observation planning.

2025, Lecture Notes in Computer Science

In this paper we develop a new semantics for disjunctive logic programs, called Well-Founded Semantics with Disjunction (WFS d ), by resorting to a fixed point-based operator. Coinciding with the Well-Founded Semantics (WFS ) for normal logic programs, our semantics is uniquely defined for every disjunctive logic program. By exploring examples, we show WFS d does not agree with any other semantics we have studied, such as Brass and Dix's D-WFS , Przymusinski's Static, Baral et al's GDWFS , Wang's WFDS , and van Gelder et al's SWFS . Despite that, we ensure WFS d is strictly stronger than D-WFS by guaranteing WFS d allows the five, desirable, program transformations proposed by Brass and Dix: unfolding, elimination of tautologies and non-minimal rules, and positive and negative reduction.

2025, Demo at the 10th AI* IA/TABOO Italian Joint Workshop “From Objects to Agents”(WOA 2009)

Social commitments are commitments made from an agent to another agent to bring about a certain property. In broad terms, a social commitment represents the commitment that an agent, called debtor, has towards another agent, called creditor, to bring about some property or state of affairs, which is the subject of the commitment. Commitments are a well-known concept in Multi-Agent Systems (MAS) research [2, 6]. Representing the commitments that the agents have to one another and specifying constraints on their ...

2025, Lecture Notes in Computer Science

In this work, we propose an operational semantics based on a proof system for the consistent execution of tasks in a constrained multi-agent setting. The tasks represent services, and are associated with abstract specifications that express conditions on such services. The constraints, contained in the body of the agents, may include -but are not limited to -policies on provided services, and limitations about the use and allocation of bounded resources. The contribution of this work is twofold. Firstly, a formalism and an operational semantics is introduced, to express the way agents can coordinate their requests of services, and to verify that they do not collide with each other's conditions. Then, we prove the soundness and completeness of such operational semantics to be used to verify the correct execution of tasks.

2025, Lecture Notes in Computer Science

This article summarises part of the work done during the first two years of the SOCS project, with respect to the task of modelling interaction amongst CL-based agents. It describes the SOCS social model: an agent interaction specification and verification framework equipped with a declarative and operational semantics, expressed in terms of abduction. The operational counterpart of the proposed framework has been implemented and integrated in SOCS-SI, a tool that can be used for on-the-fly verification of agent compliance with respect to specified protocols.

2025, Computational & Mathematical Organization Theory

Leendert van der Torre -CWI Amsterdam, Netherlands (co-chair) Harko Verhagen -DSV, KTH/SU, Sweden (co-chair)

2025, ACM Transactions on Computational Logic

SCIFF is a framework thought to specify and verify interaction in open agent societies. The SCIFF language is equipped with a semantics based on abductive logic programming; SCIFF's operational component is a new abductive logic programming proof procedure, also named SCIFF, for reasoning with expectations in dynamic environments. In this article we present the declarative and operational semantics of the SCIFF language, and the termination, soundness, and completeness results of the SCIFF proof procedure, and we demonstrate SCIFF's possible application in the multiagent domain.

2025, Proceedings of the International Workshop on Formal Approaches to Multi-Agent Systems (FAMAS)

Abstract. Agent communication is one of the key issues in multi-agent systems. Traditional interprocess communication formalisms are usually considered insufficient for this purpose because of their lack of expressiveness; thus, in most proposals for multi-agent architectures, an Agent Communication Language (ACL) is designed to provide for agent communication. However, a universally accepted standard for ACLs is still missing. Agent communication in open societies of heterogeneous agents poses requirements on ACLs ...

2025

The formal verification has become a recommended practice in safety-critical software engineering. The hand-written of the formal specification requires a formal expertise and may become complex especially with large systems. In such context, the automatic generation of the formal specification seems helpful and rewarding, particularly for reused and generic mapping such as hardware representations and real-time features. In this paper, we aim to formally verify real-time systems designed by AADL language. We propose an extension AADL2LNT of the Ocarina tool suite allowing the automatic generation of an LNT specification to draw a gateway for the CADP formal analysis toolbox. This work is illustrated with the Pacemaker case study.

2025, Theoretical Computer Science

We introduced Computed Network Process Theory to reason about protocols for mobile ad hoc networks (MANETs). Here we explore the applicability of our framework in two regards: model checking and equational reasoning. The operational semantics of our framework is based on constrained labeled transition systems (CLTSs), in which each transition label is parameterized with the set of topologies for which this transition is enabled. We illustrate how through model checking on CLTSs one can analyse mobility scenarios of MANET protocols. Furthermore, we show how by equational theory one can reason about MANETs consisting of a finite but unbounded set of nodes, in which all nodes deploy the same protocol. Model checking and equational reasoning together provide us with an appropriate framework to prove the correctness of MANETs. We demonstrate the applicability of our framework by a case study on a simple routing protocol.

2025

In this paper we study skolemization for unranked logics with classical first-order semantics. Skolemization is a transformation on first-order logic formulae, which removes all existential quantifiers from a formula. This technique is vital in proof theory and automated reasoning, especially for refutation based calculi, like resolution, tableaux, etc. Here we extend skolemization procedure to unranked formulae and prove that the procedure is sound and complete.

2025, Higher-Level Formal Languages: A Theoretical Foundation for Software System Specification

This paper presents a novel paradigm of higher-level formal languages, extending traditional formal language concepts by introducing complex entities and multidimensional relations. We develop a rigorous mathematical framework for these languages, proving key theoretical properties including the decidability of membership testing and the uniqueness of language generation from higher-level grammars. Our approach bridges the gap between abstract formal specifications and practical challenges in software system design while maintaining mathematical rigor. This theoretical foundation establishes a basis for future work on implementation techniques, verication methodologies, and practical applications in complex software systems.

2025, arXiv (Cornell University)

We describe a scheme for moving living code between a set of distributed processes coordinated with unification based Linda operations, and its application to building a comprehensive Logic programming based Internet programming framework. Mobile threads are implemented by capturing first order continuations in a compact data structure sent over the network. Code is fetched lazily from its original base turned into a server as the continuation executes at the remote site. Our code migration techniques, in combination with a dynamic recompilation scheme, ensure that heavily used code moves up smoothly on a speed hierarchy while volatile dynamic code is kept in a quickly updatable form. Among the examples, we describe how to build programmable client and server components (Web servers, in particular) and mobile agents.

2025

Hydrilla, an invasive submerged macrophyte that is classified as a noxious weed in the U.S., can quickly spread into extensive monospecific infestations, excluding other native macrophytes and disrupting entire lake ecosystems. In Florida, infestation has increased tenfold in just three years, consuming over 60% of total management costs and requiring millions of dollars in annual control efforts. Traditional monitoring methods, such as field sampling, provide accurate localized assessments but are expensive and timeconsuming. This study leverages Sentinel-2 satellite imagery, introducing the Submerged Aquatic Vegetation Index for Hydrilla (SVI H ), a novel three-band index utilizing the green (G, 560 nm), red-edge 1 (RE1, 705 nm), and shortwave infrared 1 (SWIR1, 1610 nm) bands to distinguish hydrilla from water and emergent aquatic vegetation (EAV) in two Florida lakes. The index, coupled with other vegetation indices, was validated using in situ measurements of hydrilla abundance levels, confirming its strong ability to accurately distinguish hydrilla. At the highest abundance level, SVI H produced the highest Mathew correlation coefficients (MCCs), i.e., >0.86 for Lake Yale (2021), and >0.60 (2020) and >0.68 (2021) for Lake Apopka, using three thresholding methods. For Apopka (2022), other tested indices such as MFI and FAI yielded high MCC values along with high recall using incremental search threshold. However, these indices could not distinguish EAV from SAV in the eastern regions of Lakes Apopka and Yale, where EAV was dominant. These findings encourage the use of SVI H for routine hydrilla detection and mapping, facilitating improved management, conservation efforts, and targeted herbicide applications.

2025

In this paper we are interested in refusals based model for validating timed systems. We propose a new refusals graph named timed refusals regions graphs (TRRGs). In this case specifications are modeled by durational actions timed automata (DATA*) based on maximality semantics which claim that actions have durations. This latter model is in one hand useful for modeling and validating reel aspects of systems. In the other hand, it is determinizable. In TRRG, refusals could be temporary or permanent. Permanent refusals are provoked by the nondeterminism in the specifications. However, temporary refusals are the result of the fact that actions elapse in time. We propose a framework for generating timed refusals regions graph. This framework is implemented by a combination of Meta-modelling and Graph Grammars, to transform a DATA* structure into a TRRG. This permits the automatic generation of a visual modeling tool. Finally, we argue the use of TRRG in formal test of timed systems.

2025

Preferences and contexts are fundamental aspects for deciding the best choices among possible options. We formalize the problem of propagating preferences from more generic to more specific contexts and study the key properties of... more

2025, Lecture Notes in Computer Science

In this paper, we formalize relaxed memory models by giving a parameterized operational semantics to a concurrent programming language. Behaviors of a program under a relaxed memory model are defined as behaviors of a set of related programs under the sequentially consistent model. This semantics is parameterized in the sense that different memory models can be obtained by using different relations between programs. We present one particular relation that is weaker than many memory models and accounts for the majority of sequential optimizations. We then show that the derived semantics has the DRF-guarantee, using a notion of race-freedom captured by an operational grainless semantics. Our grainless semantics bridges concurrent separation logic (CSL) and relaxed memory models naturally, which allows us to finally prove the folklore theorem that CSL is sound with relaxed memory models.

2025, Journal of Pure and Applied Algebra

A coherence result for symmetric monoidal closed categories with biproducts is shown in this paper. It is also explained how to prove coherence for compact closed categories with biproducts and for dagger compact closed categories with... more

2025, MLQ

It is proved that equations between arrows assumed for cartesian categories are maximal in the sense that extending them with any new equation in the language of free cartesian categories collapses a cartesian category into a preorder. An analogous result holds for categories with binary products, which may lack a terminal object. The proof is based on a coherence result for cartesian categories, which is related to model-theoretical methods of normalization.

2025, Studia Logica - An International Journal for Symbolic Logic

It is proved that MacLane's coherence results for monoidal and symmetric monoidal categories can be extended to some other categories with multiplication; namely, to relevant, affine and cartesian categories. All results are formulated in terms of natural transformations equipped with “graphs” (g-natural transformations) and corresponding morphism theorems are given as consequences. Using these results, some basic relations between the free

2025, Lecture Notes in Computer Science

We present a formal model for the coordination of interactions in service-oriented systems. This model provides a declarative semantics for the language SRML that is being developed under the FET-GC2 project SENSORIA for modelling and reasoning about complex services at the abstract business level. In SRML, interactions are conversational in the sense that they involve a number of correlated events that capture phenomena that are typical of SOC like committing to a pledge or revoking the effects of a deal. Events are exchanged across wires that connect the parties involved in the provision of the service.

2025, Journal of Universal Computer Science

Denotational semantics is a powerful technique to formally define programming languages. However, language constructs are not always orthogonal, so many semantic equations in a definition may have to be aware of unrelated constructs semantics. Current approaches for modularity in this formalism do not address this problem, providing, for this reason, tangled semantic definitions. This paper proposes an incremental approach for denotational semantic specifications, in which each step can either add new features or adapt existing equations, by means of a formal language based on function transformation and aspect weaving.

2025, Journal of Universal Computer Science

2025, The Journal of Logic Programming

interpretation is a theory of semantics approximation which is used for the con struction of semantics-based program analysis algorithms (sometimes called "data flow analysis"), the comparison of formal semantics (e.g., construction of a denotational semantics from an operational one), the design of proof methods, etc. Automatic program analysers are used for determining statically conservative approximations of dy namic properties of programs. Such properties of the run-time behavior of programs are useful for debug ging (e.g., type inference), code optimization (e.g., compile-time garbage collection, useless occur-check elimination), program transformation (e.g., partial evaluation, parallelization), and even program cor rectness proofs (e.g., termination proof). After a few simple introductory examples, we recall the classical framework for abstract interpretation of programs. Starting from a standard operational semantics formalized as a transition system, classes of program properties are first encapsulated in collecting semantics expressed as fixpoints on partial orders representing concrete program properties. We consider invariance properties characterizing the descendant states of the initial states (corresponding to top/down or forward analyses), the ascendant states of the final states (corresponding to bottom/up or backward analyses) as well as a combination of the two. Then we choose specific approximate abstract properties to be gathered about program behaviors and express them as elements of a poset of abstract properties. The correspondence between concrete and abstract properties is established by a concretization and abstraction function that is a Galois connection formalizing the loss of information. We can then constructively derive the abstract program properties from the collecting semantics by a formal computation leading to a fixpoint expression in terms of abstract operators on the domain of abstract properties. The design of the abstract interpreter then involves the choice of a chaotic iteration strategy to solve this abstract fixpoint equation. We insist on the compositional design of this abstract interpreter, which is formalized by a series of propositions for designing Galois connections (such as Moore families, decomposition by partitioning, reduced product, down-set completion, etc.). Then we recall the convergence acceleration methods using widening and narrowing allowing for the use of very expressive infinite domains of abstract properties. We show that this classical formal framework can be applied in extenso to logic programs. For simplicity, we use a variant of SLD-resolution as the standard operational semantics. The first example is groundness analysis, which is a variant of Mellish mode analysis. It is extended to a combination of top/down and bottom/up analyses. The second example is the derivation of constraints among argument sizes, which involves an infinite abstract domain requiring the use of convergence acceleration methods. We end up with a short thematic guide to the literature on abstract interpretation of logic programs.