Operational Semantics

Contemporary debates surrounding large language models (LLMs) oscillate between two inadequate extremes: reductive mechanistic accounts that deny meaningful semantic organization, and anthropomorphic accounts that prematurely attribute human-like consciousness to artificial systems. This paper argues that both frameworks fail to characterize the emergent semantic behaviors observed in transformer-based architectures. We propose Operational Semantic Understanding (OSU), defined as the capacity of an artificial system to manipulate semantic content coherently, contextually, adaptively, and inferentially without requiring evidence of phenomenological consciousness. We further introduce Artificial Semantogenesis, referring to the emergence of functional semantic organization through large-scale relational learning within distributed inferential architectures. Both concepts are positioned relative to established philosophical accounts, including Dennett's intentional stance, Dretske's informational semantics, and Harnad's symbol grounding problem. We argue that contemporary LLMs may constitute a novel category of inferential artificial cognition, and propose an expanded cognitive taxonomy distinguishing Biological Phenomenological Cognition, Symbolic Computational Cognition, Inferential Artificial Cognition, and Hybrid Relational Cognition-the latter describing emergent knowledge coproduction through sustained human-AI collaboration. Future research, we contend, should move beyond binary debates about whether AI systems "truly understand" and develop more precise frameworks for describing operational semantic functionality across diverse cognitive architectures.

We propose a new framework for the syntax and semantics of Weak Hereditarily Harrop logic programming with constraints, based on resolution over -categories: ÿnite product categories with canonical structure. Constraint information is directly built-in to the notion of signature via categorical syntax. Many-sorted equational constraints are a special case of the formalism which combines features of uniform logic programming languages (modules and hypothetical implication) with those of constraint logic programming. Using the canonical structure supplied by -categories, we deÿne a diagrammatic generalization of formulas, goals, programs and resolution proofs up to equality (rather than just up to isomorphism). We extend the Kowalski-van Emden ÿxed point interpretation, a cornerstone of declarative semantics, to an operational, non-ground, categorical semantics based on indexing over sorts and programs. We also introduce a topos-theoretic declarative semantics and show soundness and completeness of resolution proofs and of a sequent calculus over the categorical signature. We conclude with a discussion of semantic perspectives on uniform logic programming.

We have recently introduced the "continuation semantics for concurrency" (CSC) technique in an attempt to exploit the benefits of using continuations in concurrent systems development. CSC is a general technique for denotational semantics which provides excellent flexibility in the compositional modeling of concurrent control concepts. In this paper, we present a denotational semantics designed with CSC for a distributed languages incorporating two control concepts which have not been modeled denotationally before: remote object (process) destruction, and cloning.

The problem of legacy systems collaboration is being solved. Particularly we look at the collaboration as workflow in a distributed and heterogeneous environment. Attention is paid to the description of semantics for workflow process definition languages. There are many solutions how semantics can be decomposed into logical fragments, but the problem of obtaining reusable components that are easy to compile into desired specific semantics still remains. We evolve the division of semantics by semantic aspects whose description is based on abstract data types (pre-built components) and connectors (meta-programs to produce the glue code) between them. This paper offers a way in which semantic aspects are linked with the intermediate representation of a program, and performing of semantics is provided. We mix together various semantics aspects to get a desirable semantics.

The program dependence graph (PDG) represents data and control dependence between statements in a program. This paper presents an operational semantics of program dependence graphs. Since PDGs exclude artificial order of statements that resides in sequential programs, executions of PDGs are not unique. However, we identified a class of PDGs that have unique final states of executions, called deterministic PDGs. We prove that the operational semantics of control flow graphs is equivalent to that of deterministic PDGs. The class of deterministic PDGs properly include PDGs obtained from well-structured programs. Thus, our operational semantics of PDGs is more general than that of PDGs for well-structured programs, which are already established in literature.

The program dependence graph (PDG) represents data and control dependence between statements in a program. This paper presents an operational semantics of program dependence graphs. Since PDGs exclude artificial order of statements that resides in sequential programs, executions of PDGs are not unique. However, we identified a class of PDGs that have unique final states of executions, called deterministic PDGs. We prove that the operational semantics of control flow graphs is equivalent to that of deterministic PDGs. The class of deterministic PDGs properly include PDGs obtained from well-structured programs. Thus, our operational semantics of PDGs is more general than that of PDGs for well-structured programs, which are already established in literature.

We propose a dependent type theory that integrates programming, specifications, and reasoning about higher-order concurrent programs with shared transactional memory. The design builds upon our previous work on Hoare Type Theory (HTT), which we extend with types that correspond to Hoare-style specifications for transactions. The types track shared and local state of the process separately, and enforce that shared state always satisfies a given invariant, except at specific critical sections which appear to execute atomically. Atomic sections may violate the invariant, but must restore it upon exit. HTT follows Separation Logic in providing tight specifications of space requirements. As a logic, we argue that HTT is sound and compositional. As a programming language, we define its operational semantics and show adequacy with respect to specifications.

In this work, we present a family of operational semantics that gradually approximates the realistic program behaviors in the C/C++11 memory model. Each semantics in our framework is built by elaborating and combining two simple ingredients: viewfronts and operation buffers. Viewfronts allow us to express the spatial aspect of thread interaction, i.e., which values a thread can read, while operation buffers enable manipulation with the temporal execution aspect, i.e., determining the order in which the results of certain operations can be observed by concurrently running threads. Starting from a simple abstract state machine, through a series of gradual refinements of the abstract state, we capture such language aspects and synchronization primitives as release/acquire atomics, sequentially-consistent and non-atomic memory accesses, also providing a semantics for relaxed atomics, while avoiding the Out-of-Thin-Air problem. To the best of our knowledge, this is the first formal and executable operational semantics of C11 capable of expressing all essential concurrent aspects of the standard. We illustrate our approach via a number of characteristic examples, relating the observed behaviors to those of standard litmus test programs from the literature. We provide an executable implementation of the semantics in PLT Redex, along with a number of implemented litmus tests and examples, and showcase our prototype on a large case study: randomized testing and debugging of a realistic Read-Copy-Update data structure.

We propose a dependent type theory that integrates programming, specifications, and reasoning about higher-order concurrent programs with shared transactional memory. The design builds upon our previous work on Hoare Type Theory (HTT), which we extend with types that correspond to Hoare-style specifications for transactions. The types track shared and local state of the process separately, and enforce that shared state always satisfies a given invariant, except at specific critical sections which appear to execute atomically. Atomic sections may violate the invariant, but must restore it upon exit. HTT follows Separation Logic in providing tight specifications of space requirements. As a logic, we argue that HTT is sound and compositional. As a programming language, we define its operational semantics and show adequacy with respect to specifications.

A model checker is an automatic tool that traverses a specific structure (normally a Kripke structure referred as the model M ) to check the satisfaction of some (temporal) logical property f . This is formally stated as M | f . For some formal notations, the model M of a specification S (written in a formal language L) can be described as a labelled transition system (LTS). Specifically, it is not clear in general how usual tools such as SPIN, FDR, PAT, etc., create the LTS representation from a given process. Although one expects the coherence of the LTS generation with the semantics of L, it is completely hidden inside the model checker itself. In this paper we show how to create a model checker for L, using a development approach based on its operational semantics. We use a systematic semantics embedding and the formal modeling using logic programming and analysis (FOR-MULA) framework to this end. We illustrate our strategy considering the formal language COMPASS modelling language (CML)-a new language that was based on CSP, VDM and the refinement calculus proposed for modelling and analysis of systems of systems. As FORMULA is based on satisfiability modulo theories solving, our model checker can handle communications and predicates involving data with infinite domains by building and manipulating a symbolic LTS. This goes beyond the capabilities of traditional CSP model checkers such as FDR and PAT. Moreover, we show how to reduce time and space complexities by simple semantic modifications in the embedding. This allows a more semantics-preserving tuning. Finally, we show a real implementation of our model checker in an integrated development platform for CML and its practical use on an industrial case study.

The development of distributed real-time embedded systems presents a significant practical challenge both because of the complexity of distributed computation and because of the need to rapidly assess a wide variety of design alternatives in early stages when requirements are often volatile. Formal methods can address some of these challenges but are often thought to require greater initial investment and longer development cycles than is desirable for the development of non-critical systems in highly competitive markets. In this paper we propose an approach that takes advantage of formal modelling and analysis technology in a lightweight way, making significant use of readily available tools. We describe an incremental approach in which detail is progressively added to abstract system-level specifications of functional and timing properties via intermediate models that express system architecture, concurrency and distribution. The approach is illustrated using a model of a home automation system. The models are expressed using the Vienna Development Method (VDM) and are validated primarily by scenario-based tests.

When implementing a new programming language construct, it is important to consider and understand its implications on program semantics. Simply hacking compiler code, even in combination with the use of a debugger, does not allow for easily keeping track of the global picture of overall execution semantics. We present a graph-based implementation of the delMDSOC virtual machine (VM) model in AGG, as a platform for experimenting with programming language constructs. More specifically, given the nature of the delMDSOC model, it is aimed primarily at languages supporting the modularization of crosscutting concerns, such as aspect-oriented or context-oriented languages. Our delMDSOC implementation visualizes programs as graphs at the VM level, in terms of well-known and intuitive concepts: objects, messages, delegation and actors. Implementing new high-level language constructs involves expressing them in terms of these concepts. Since delMDSOC is implemented as a graph rewriting system, program execution can be visually simulated and program state can be inspected at all times, providing insight in the implications of the new language construct on execution semantics. We demonstrate our approach by means of two language constructs: the context-oriented layer construct and a new aspect-oriented construct, the "concurrent cflow" pointcut.

We present a process algebra for modeling and reasoning about Mobile Ad hoc Networks (MANETs) and their protocols. In our algebra we model the essential modeling concepts of ad hoc networks, i.e. local broadcast, connectivity of nodes and connectivity changes. Connectivity and connectivity changes are modeled implicitly in the semantics, which results in a more compact state space. Our connectivity model supports unidirectional links. A key feature of our algebra is eliminating connectivity information from the specification of a network, and transferring its complexity to the semantics. We give a formal operational semantics for our process algebra, and define equivalence relations on protocols and networks. We show how our algebra can be applied to prove correctness of an ad hoc routing protocol.

We investigate the effects of semantically-based crossover operators in genetic programming, applied to real-valued symbolic regression problems. We propose two new relations derived from the semantic distance between subtrees, known as semantic equivalence and semantic similarity. These relations are used to guide variants of the crossover operator, resulting in two new crossover operatorssemantics aware crossover (SAC) and semantic similarity-based crossover (SSC). SAC, was introduced and previously studied, is added here for the purpose of comparison and analysis. SSC extends SAC by more closely controlling the semantic distance between subtrees to which crossover may be applied. The new operators were tested on some real-valued symbolic regression problems and compared with standard crossover (SC), context aware crossover (CAC), Soft Brood Selection (SBS), and No Same Mate (NSM) selection. The experimental results show on the problems examined that, with computational effort measured by the number of function node evaluations, only SSC and SBS were significantly better

We introduce the notion of deferential logic programs and we define an operator for composing them in a hierarchical fashion. The semantics of this composition operator is reminiscent of the semantics of inheritance in the object oriented paradigm. Similar to classes in that paradigm, differential programs can be organized in isa schemas where each component inherits or redefines, modifying them, the predicates defined in the components that are placed higher up in the schema. We demonstrate the use of this form of composition as a programming methodology that enhances reusability, code sharing and information hiding. We define a proof theory and a model theory for the composition of differential programs and we prove that the two theories coincide. We also define a compositional and fully abstract semantics for differential programs and we address the importance of this semantics as a formal tool for reasoning on the computational properties of differential programs and their composition.

ii Dedication To my parents iii Acknowledgements Thanks are first due to my adviser, Tim Sheard without whose help and encouragement none of this would be possible. Acknowledgments and thanks are due to Walid Taha: much of the research presented in Chapter 2 was conducted in collaboration with him and Tim. Also, I wish to thank the members of my thesis committee for their patience and helpful suggestions. Finally, friends and colleagues whose input over the years has been essential: Zino Benaissa, Bruno Barbier, Iavor Diatchki, Levent Erkök, Bill Harrison and many others. iv Contents

Proposed and developed is the language Service Composition (SC) CoJava, which extends the programming language Java with (1) a modular service composition framework; (2) an extensible library of supply-chain modeling components such as items, services and business metrics; and (3) decision choice constructs for program variables, assertions of constraints and a designation of a program variable to serve as the objective to be minimized or maximized. The SC-CoJava provides not only the procedural "simulation-like" semantics of Java, but also an optimization semantics. The optimization semantics of SC-CoJava amounts to ( ) finding an optimal instantiation of values into the choice-variables, based on automatic construction of a standard optimization model and solving it using a mathematical programming solver, and then (2) executing the Java program procedurally, where all the decision choice values are taken from the optimization result.

The majority of abstract interpretation models defined for Prolog use abstract operations which do not have explicit counterpart in the SLD-resolution. We propose, in this paper, an operational semantics closely related to these models. We prove his equivalence with the SLDresolution and then we use it to prove the consistency of one of abstract semantics presents in 9].

The majority of abstract interpretation models defined for Prolog use abstract operations which do not have explicit counterpart in the SLD-resolution. We propose, in this paper, an operational semantics closely related to these models. We prove his equivalence with the SLDresolution and then we use it to prove the consistency of one of abstract semantics presents in [7, 8, 9]. Key-words: Logique programming, SLD-resolution, static analysis, abstract interpretation, program semantics.

Presented in this work is a novel approach to implement an efficient abstract interpretation algorithm for logic programs by means of attributed grammar. Successful implementation of this algorithm yielded memory storage saving and run-time reduced. We first execute the algorithm presented in [2](slightly modified), which generates a tree with four types of nodes. We then store in computer memory only the pertinent subtrees. In other words, after each step, we prune some branches of tree and develop only the subtree which can improve the ”oracle” (i.e. set of abstract tuple).

iSCSI is an emerging communication protocol enabling block data transport over TCP/IP network. This paper uses a storage architecture allowing parallel processing of iSCSI commands and presents two novel techniques for improving the performance of iSCSI protocol -the first is the elimination technique for reducing latency caused by redundant overwrites and second technique reduces the latency caused due to multiple reads to same storage sector. The theoretical performance analysis shows that use of operation semantics has the potential to improve performance as compared to the existing iSCSI protocol.

Admissible Graph Rewriting and Narrowing Rachid Echahed and Jean-Christophe Janodet Laboratoire LEIBNIZ, IMAG, CNRS 46, avenue Felix Viallet F-38031 Grenoble-France Rachid. Echahed@ imag. fr; Jean-Christophe. Janodet@ imag. fr Abstract We address ...

Institute of Mathematics of the Academy of Sciences of the Czech Republic provides access to digitized documents strictly for personal use. Each copy of any part of this document must contain these Terms of use. This paper has been digitized, optimized for electronic delivery and stamped with digital signature within the project DML-CZ: The Czech Digital Mathematics Library

Institute of Mathematics of the Academy of Sciences of the Czech Republic provides access to digitized documents strictly for personal use. Each copy of any part of this document must contain these Terms of use. This paper has been digitized, optimized for electronic delivery and stamped with digital signature within the project DML-CZ: The Czech Digital Mathematics Library

Join point models are one of the key features in aspectoriented programming languages and tools. They provide software engineers means to pinpoint the exact locations in programs (join points) to weave in advices. Our experience in modularizing concerns in a large embedded system showed that existing join point models and their underlying program representations are not expressive enough. This prevents the selection of some join points of our interest. In this paper, we motivate the need for more fine-grained join point models within more expressive source code representations. We propose a new program representation called a program graph, over which more fine-grained join point models can be defined. In addition, we present a simple language to manipulate program graphs to perform source code transformations. This language thus can be used for specifying complex weaving algorithms over program graphs.

The composition of multiple software units does not always yield the desired results. In particular, aspect-oriented composition mechanisms introduce new kinds of composition problems. These are caused by different characteristics as compared to object-oriented composition, such as inverse dependencies. The aim of this paper is to contribute to the understanding of aspect-oriented composition problems, and eventually composition problems in a more general context. To this extent we propose and illustrate a systematic approach to analyze composition problems in a precise and concrete manner. In this approach we represent aspectbased composition mechanisms as transformation rules on program graphs. We explicitly model and show where composition problems occur, in a way that can easily be fully automated. In this paper we focus on structural superimposition (cf. intertype declarations) to illustrate our approach; this results in the identification of three categories of causes of composition problems.

Non-monotonic reasoning constitutes an approach to reasoning with incomplete or changing information and is significantly more powerful than standard reasoning, which simply deals with universal statements. Defeasible reasoning, a member of the non-monotonic reasoning family, offers the extra capability of dealing with conflicting information and can represent facts, rules and priorities among rules. The main advantages of defeasible reasoning, however, are not only limited to its enhanced representational ...

This paper presents DR-DEVICE, a system for defeasible reasoning on the Web. Defeasible reasoning is a rule-based approach for efficient reasoning with incomplete and inconsistent information. Such reasoning is, among others, useful for ontology integration, where conflicting information arises naturally; and for the modeling of business rules and policies, where rules with exceptions are often used. In this paper we describe these scenarios in more detail along with the implementation of the DR-DEVICE system, which is capable of reasoning about RDF data over multiple Web sources using defeasible logic rules. The system is implemented on top of CLIPS production rule system and builds upon R-DEVICE, an earlier deductive rule system over RDF data that also supports derived attribute and aggregate attribute rules. Rules can be expressed either in a native CLIPS-like language, or in an extension of the OO-RuleML syntax. The operational semantics of defeasible logic are implemented through compilation into the generic rule language of R-DEVICE. The paper includes a use case of a semantic web broker that reasons defeasibly about renting apartments based on buyer's requirements (expressed RuleML defeasible logic rules) and seller's advertisements (expressed in RDF).

In the context of systems security, information flows play a central role. Unhandled information flows potentially leave the door open to very dangerous types of attacks, such as code injection or sensitive information leakage. Information flows verification is based on the definition of Non-Interference [8], which is known to be an hyperproperty [7], i.e., a property of sets of executions. The sound verification of hyperproperties is not trivial [3, 16]: It is not easy to adapt classic verification methods, used for trace properties, in order to deal with hyperproperties. In the present work, we design an abstract interpretation-based static analyzer soundly checking Non-Interference. In particular, we define an hyper abstract domain, able to approximate the information flows occurring in the analyzed programs.

Business-to-Business integration (B2Bi) as a core concept of Supply Chain Management (SCM) is a key success factor for enterprises today. Frequently, choreography models are used for agreeing about the overall message exchanges among integration partners while executable orchestration models derived from the choreography govern the local message flow of each individual participant. Today, ebXML BPSS (ebBP) as a dedicated B2Bi choreography language and WS-BPEL as the de-facto standard for Web service based orchestration modeling provide the technological basis for integrating choreographies and orchestrations in the B2Bi domain. This paper introduces the concept of partner-shared states into ebXML BPSS (ebBP) choreography modeling in order to enable complex integration scenarios and shows how to implement these using Web services and WS-BPEL technology. Shared states explicitly represent the effect of business document exchanges, provide natural synchronization points for attaching admissible message exchange actions, and allow for controlling distributed timeouts as well as comprehensibly communicating the interaction's progress. We provide a workaround for modeling shared states in an ebBP schema compliant way as well as an ebBP schema extension that enables intuitive and straightforward models. A formalization of shared state-based ebBP models is introduced as concise basis for automatically translating extension-based ebBP models into workaround-based ebBP models. An operational semantics for shared state-based ebBP models using this formalization is utilized for comprehensibility because ebBP itself does not define clear semantics.

In this paper, we study the semantics of a specification language for the coordination of concurrent systems, which supports time at different levels: various time domains, polychrony, and mixed metric/logical time constraints. The language itself is defined by a denotational semantics. In order to be able to construct the possible timelines for verification purposes, we also define a symbolic operational semantics, which is the reference for an efficient implementation of a tool for runtime-testing of heterogeneous systems. This study presents a novel way to link these two semantics by taking advantage of a coinductive unfolding principle of these timelines. Furthermore, these semantics and their equivalence have been formalized in the Isabelle/HOL proof assistant, together with proofs for soundness, completeness and progress.

There is a plethora of semantics of computational models, nevertheless, the semantics of combinatory logic are among the less investigated ones. In this paper, we propose semantics for the computational system of combinatory logic with intersection types. We define extensional applicative structures endowed with special elements corresponding to primitive combinators. We prove two soundness and completeness results. First, the equational theory of untyped combinatory logic is proven to be sound and complete with respect to the proposed semantics. Second, the system of the combinatory logic with intersection types is proven to be sound and complete with respect to the proposed semantics. The usual approach to the semantics for calculi with types that can be found in the literature is based on models for the untyped calculus endowed with a valuation of type variables which enables the interpretation of types to be defined inductively. We propose, however, a different approach. In the ...

In this paper we study the model of Time Petri Nets (TPNs) where a time interval is associated with the firing of a transition, but we extend it by considering general intervals rather than closed ones. A key feature of timed models is the memory policy, i.e. which timing informations are kept when a transition is fired. The original model selects an intermediate semantics where the transitions disabled after consuming the tokens, as well as the firing transition, are reinitialised. However this semantics is not appropriate for some applications. So we consider here two alternative semantics: the atomic and the persistent atomic ones. First we present relevant patterns of discrete event systems which show the interest of these semantics. Then we compare the expressiveness of the three semantics w.r.t. the weak time bisimilarity establishing inclusion results in the general case. Furthermore we show that some inclusions are strict with unrestricted intervals even when nets are bounded. Then we focus on bounded TPNs with upper-closed intervals and we prove that the semantics are equivalent. Finally taking into account both the practical and the theoretical issues, we conclude that persistent atomic semantics should be preferred.

Es inevitable que algunas consideraciones sean transversales a una aplicación de cierto tamaño, lo que resulta en código repartido en ella, mezclado con el código de otras consideraciones. Este problema es particularmente severo en el caso de la seguridad: se torna difı́cil estar seguro acerca de que ́ tan segura es la aplicación cuando su implemntación esta repartida y mezclada en la base de código. El razonamiento global acerca de la seguridad se vuelve precario. En esta tesis, consideramos el caso del control de acceso, un pilar fundamental de toda arquitectura de seguridad. El control de acceso resulta ser una consideración transversal con una implementación no modular basada en la inspección del stack en tiempo de ejecución en lenguajes como Java y C#. En esta tesis usamos la orientación a aspectos para definir modularmente el control de acceso. Más pre-cisamente, presentamos el diseño e implmentación del control de acceso, incluyendo sus caracterı́sticas avanzad...

Es inevitable que algunas consideraciones sean transversales a una aplicación de cierto tamaño, lo que resulta en código repartido en ella, mezclado con el código de otras consideraciones. Este problema es particularmente severo en el caso de la seguridad: se torna difícil estar seguro acerca de qué tan segura es la aplicación cuando su implemntación esta repartida y mezclada en la base de código. El razonamiento global acerca de la seguridad se vuelve precario. En esta tesis, consideramos el caso del control de acceso, un pilar fundamental de toda arquitectura de seguridad. El control de acceso resulta ser una consideración transversal con una implementación no modular basada en la inspección del stack en tiempo de ejecución en lenguajes como Java y C#. En esta tesis usamos la orientación a aspectos para definir modularmente el control de acceso. Más precisamente, presentamos el diseño e implmentación del control de acceso, incluyendo sus características avanzadas, de una forma modular. Finalmente, demostramos que esta implementación modular es segura, incluso en presencia de aspectos no confiables. Una implementación modular como esta soluciona los problemas de mantenimiento y evolución producidos por la naturaleza transversal del control de acceso, pero más importante aun, pavimenta el camino para el razonamiento global acerca del control de acceso.

This paper proves correctness of Nöcker's method of strictness analysis, implemented in the Clean compiler, which is an effective way for strictness analysis in lazy functional languages based on their operational semantics. We improve upon the work Clark, Hankin and Hunt did on the correctness of the abstract reduction rules in two aspects. Our correctness proof is based on a functional core language and a contextual semantics, thus proving a wider range of strictness-based optimizations as correct, and our method fully considers the cycle detection rules, which contribute to the strength of Nöcker's strictness analysis. Our algorithm SAL is a reformulation of Nöcker's strictness analysis algorithm in a functional core language LR. This is a higher order call-by-need lambda calculus with case, constructors, letrec, and seq, which is extended during strictness analysis by set constants like Top or Inf , denoting sets of expressions, which indicate different evaluation demands. It is also possible to define new set constants by recursive equations with a greatest fixpoint semantics. The operational semantics of LR is a small-step semantics. Equality of expressions is defined by a contextual semantics that observes termination of expressions. Basically, SAL is a nontermination checker. The proof of its correctness and hence of Nöcker's strictness analysis is based mainly on an exact analysis of the lengths of evaluations, i.e., normal-order reduction sequences to WHNF. The main measure being the number of "essential" reductions in evaluations. Our tools and results provide new insights into call-by-need lambda calculi, the role of sharing in functional programming languages, and into strictness analysis in general. The correctness result provides a foundation for Nöcker's strictness analysis in Clean, and also for its use in Haskell.

This paper proves correctness of Nöcker's method of strictness analysis, implemented in the Clean compiler, which is an effective way for strictness analysis in lazy functional languages based on their operational semantics. We improve upon the work Clark, Hankin and Hunt did on the correctness of the abstract reduction rules in two aspects. Our correctness proof is based on a functional core language and a contextual semantics, thus proving a wider range of strictness-based optimizations as correct, and our method fully considers the cycle detection rules, which contribute to the strength of Nöcker's strictness analysis. Our algorithm SAL is a reformulation of Nöcker's strictness analysis algorithm in a functional core language LR. This is a higher order call-by-need lambda calculus with case, constructors, letrec, and seq, which is extended during strictness analysis by set constants like Top or Inf , denoting sets of expressions, which indicate different evaluation demands. It is also possible to define new set constants by recursive equations with a greatest fixpoint semantics. The operational semantics of LR is a small-step semantics. Equality of expressions is defined by a contextual semantics that observes termination of expressions. Basically, SAL is a nontermination checker. The proof of its correctness and hence of Nöcker's strictness analysis is based mainly on an exact analysis of the lengths of evaluations, i.e., normal-order reduction sequences to WHNF. The main measure being the number of "essential" reductions in evaluations. Our tools and results provide new insights into call-by-need lambda calculi, the role of sharing in functional programming languages, and into strictness analysis in general. The correctness result provides a foundation for Nöcker's strictness analysis in Clean, and also for its use in Haskell.

This paper describes context analysis, an extension to strictness analysis for lazy functional languages. In particular it extends Wadler's four point domain and permits in nitely many abstract values. A calculus is presented based on abstract reduction which g i v en the abstract values for the result automatically nds the abstract values for the arguments. The results of the analysis are useful for veri cation purposes and can also be used in compilers which require strictness information.

PILOT (Programming and Interpreted Language Of actions for Telerobotics) is a graphical and interpreted language dedicated to the r emote control of systems. It is provided with a control system whose various modules have been modeled with the help of f inite state automata. The work described in this paper follows a preceding work which consisted in applying static and

We develop an axiomatic mathematical framework for \emph{balance-preserving operations}
on networks, in which every local transformation is required to conserve a global quantity
through mandatory redistribution to neighboring states. The framework is formulated on
undirected weighted graphs and treats operations, rather than static values, as the primary
mathematical objects. Classical arithmetic and algebra are shown to arise as lossy projections
that discard remainder information and therefore fail to represent process-level conservation
in closed systems.

A canonical class of balance-preserving dynamics is introduced and shown to satisfy global
conservation exactly for general symmetric edge weights. Under explicit scaling assumptions,
these discrete dynamics admit well-defined continuum limits, yielding diffusion and
diffusion--decay equations without imposing conservation laws externally. The weighted
formulation subsumes the unweighted case as a strict special instance.

Beyond linear dynamics, threshold and saturation operators are incorporated while preserving
global balance. Numerical experiments demonstrate the emergence of spatially localized,
long-lived structures such as stable islands, sharp fronts, hysteresis, and cascade phenomena.
To formalize these effects, we introduce \emph{Hierarchical Critical Flow Theory}, which
organizes balance-preserving dynamics into nested subsystems regulated by capacity and
imbalance thresholds, enabling deterministic analysis of cascades, regime switching, and
stopping conditions.

The framework is further extended by introducing a gauge--invariant \emph{operational
stabilization cost} and associated capacity bounds, providing a unified scaling mechanism
across physical, biological, social, and astrophysical regimes. Observable scale-dependent
quantities are shown to arise as domain-specific coarse-grainings of the same underlying
cost--capacity relation, with empirical calibration requiring only a single reference anchor.

All statements are explicitly classified by epistemic status (Established, Effective,
Conjectural, Protocol), and the work delineates a disciplined research program spanning graph
dynamics, threshold-driven PDEs, hierarchical transport, operational geometry, and the
endogenization of operational laws. The resulting framework provides a unified operational
language for conservation, transport, critical transitions, and emergent structure in
networked systems.

We introduce Dynamic SOS as a framework for describing semantics of programming languages that include dynamic software upgrades. Dynamic SOS is built on top of the Modular SOS of P. Mosses, with an underlying category theory formalization. Dynamic SOS wants to bring out the essential differences between dynamic upgrade constructs and execution constructs. The important feature of Modular SOS that we exploit in our framework is the sharp separation of the program code from the additional data structures needed at run-time. We exemplify Dynamic SOS on the C-like Proteus language and the concurrent object-oriented Creol language. On the way we introduce a construction on Modular SOS useful in the setting of the concurrent objects of Creol, where the executing code is running inside the object. This "encapsulating construction" may be used in any situation where a form of encapsulation of the execution is needed.