A Graph Model for Imperative Computation

Scott's graph model is a lambda-algebra based on the observation that continuous endofunctions on the lattice of sets of natural numbers can be represented via their graphs. A graph is a relation mapping finite sets of input values to output values. We consider a similar model based on relations whose input values are finite sequences rather than sets. This alteration means that we are taking into account the order in which observations are made. This new notion of graph gives rise to a model of affine lambda-calculus that admits an interpretation of imperative constructs including variable assignment, dereferencing and allocation. Extending this untyped model, we construct a category that provides a model of typed higher-order imperative computation with an affine type system. An appropriate language of this kind is Reynolds's Syntactic Control of Interference. Our model turns out to be fully abstract for this language. At a concrete level, it is the same as Reddy's object spaces model, which was the first "state-free" model of a higher-order imperative programming language and an important precursor of games models. The graph model can therefore be seen as a universal domain for Reddy's model

Automated Refinement Of Hierarchical Object Graphs

Object graphs help explain the runtime structure of a system. To make object graphs convey design intent, one insight is to use abstraction by hierarchy, i.e., to show objects that are implementation details as children of architecturally-relevant objects from the application domain. But additional information is needed to express this object hierarchy, using ownership type qualifiers in the code. Adding qualifiers after the fact involves manual overhead, and requires developers to switch between adding qualifiers in the code and looking at abstract object graphs to understand the object structures that the qualifiers describe. We propose an approach where developers express their design intent by refining an object graph directly, while an inference analysis infers valid qualifiers in the code. We present, formalize and implement the inference analysis. Novel features of the inference analysis compared to closely related work include a larger set of qualifiers to support less restrictive object hierarchy (logical containment) in addition to strict hierarchy (strict encapsulation), as well as object uniqueness and object borrowing. A separate extraction analysis then uses these qualifiers and extracts an updated object graph. We evaluate the approach on two subject systems. One of the subject systems is reproduced from an experiment using related techniques and another ownership type system, which enables a meaningful comparison. For the other subject system, we use its documentation to pick refinements that express design intent. We compute metrics on the refinements (how many attempts on each subject system) and classify them by their type. We also compute metrics on the inferred qualifiers and metrics on the object graphs to enable quantitative comparison. Moreover, we qualitatively compare the hierarchical object graphs with the flat object graphs and with each other, by highlighting how they express design intent. Finally, we confirm that the approach can infer from refinements valid qualifiers such that the extracted object graphs reflect the design intent of the refinements

engineering approach to atomic transaction verification: use of a simple object model to achieve semantics-based reasoning at compile-time

In this paper, we take an engineering approach to atomic transaction verification. We discuss the design and implementation of a verification tool that can reason about the semantics of atomic database operations. To bridge the gap between language design and automated reasoning, we make use of a simple model of objects that imitates the type-tagged memory structure of an implementation. This simple model is sufficient to describe the operational semantics of the typical features of an object-oriented database programming language, such as bounded iteration, heterogeneity, object creation, and nil values. The same model lends itself to automated reasoning with a theorem prover system. We are thus able to apply theorem prover technology to verification problems that address transaction semantics. The work has applications in the areas of transaction safety, semantics-based concurrency control, and cooperative work. The approach is illustrated by a graph editing example, with heterogeneous node structures

A comparative study of computer models for friction and their influence on dynamics of the heavy rigid body on a horizontal surface

Using an example of a heavy rigid body moving on a horizontal surface and having with it a permanent contact the process of construction and verification for spatial dynamical models of the multibody systems is analyzed. Two approaches to formal representation of the models: object-oriented, and bond graph based are applied. Energy based similarities between these approaches are analyzed. A detailed description of the bond graph representation for the most general type of constraint is presented. It turned out the resulting total bond graph model of the multibody system dynamics always has exactly a so-called canonical junction structure. This representation has a tight correspondence with our object-oriented implementation of the mechanical constraint architecture. As an example Modelica implementation of several classes in the row for mechanical contact is investigated. Computer implementations for three examples of the heavy rigid body dynamics are under investigation: (a) the rattleback, (b) example of A. P. Markeev, (c) the Tippe- Top. Among all of three examples each one demonstrates in its own manner a peculiar dynamical behaviour

Program slicing of Java programs

[EN] Program slicing is a technique to extract the part of the program that can affect the values computed at a given program point (known as the slicing criterion). To represent programs, program slicing uses the System Dependence Graph (SDG), for which several extensions like the Java System Dependence Graph (JSysDG) or the Sub-Statement Linear Dependence Graph (SSLDG) exist to deal with Java object-oriented programs. In this paper, we present an incompleteness result proving that these graphs do not produce complete slices in all cases, and specifically when some object variables are selected as the slicing criterion. We first identify the source of the problem: the representation of dependences between partial definitions of objects is ill-defined in these approaches, leading to a loss of completeness in many cases. To solve this limitation, we extend these representations with the addition of a specific flow dependence for object type variables called object-flow dependence. This extension provides a more accurate flow representation between object variables and its data members and it allows us to obtain complete slices when an object variable is selected as the slicing criterion.(c) 2022 The Authors. Published by Elsevier Inc. This is an open access article under the CC BY-NC-ND license (http://creativecommons.org/licenses/by-nc-nd/4.0/).This work has been partially supported by grant PID2019-104735RB-C41 funded by Spanish MCI/AEI/10.13039/501100011033, by the Generalitat Valenciana under grant Prometeo/2019/098 (DeepTrust), and by TAILOR, a project funded by EU Horizon 2020 research and innovation programme under GA No 952215. Carlos Galindo was partially supported by the Spanish Ministerio de Universidades under grant FPU20/03861. Sergio Perez was partially supported by Universitat Politecnica de Valencia under FPI grant PAID-01-18.Galindo, C.; Pérez, S.; Silva, J. (2023). Program slicing of Java programs. Journal of Logical and Algebraic Methods in Programming. 130. https://doi.org/10.1016/j.jlamp.2022.10082613

Mechanical Constraint Arrangement and Its Multibond Graph Representation

When developing a computer model of the multibody system (MBS) dynamics it is interesting to have a unified technology to construct the models in an efficient way. It turns out object-oriented approach provides a tools to resolve such a problem successively step by step. One of these unified ways is connected tightly with the so-called multiport representation of the models initially based on the bond graph use. These latter ones in turn based on the idea of energy exchanges, and substantially on energy conservation for physically interconnected subsystems of any engineering type. A detailed description of the multibond graph representation for the most general type of constraint is presented. It turned out the resulting total multibond graph model of the multibody system dynamics always has exactly a canonical junction structure. This representation has a tight correspondence with our previous object-oriented implementation of the mechanical constraint architecture. Computational experience makes it possible to classify objects of the multibody system dynamics. Such a model includes two classes of objects. They correspond to notions of 'body' and 'constraint'. Each of these notions indeed corresponds to the certain type of the multibond graph junction

Graphs and Graph Transformations for Object-Oriented and Service-Oriented Systems

Theories of graphs and graph transformations form an important part of the mathematical foundations of computing, and have been applied in a wide range of areas from the design and analysis of algorithms to the formalization of various computer systems and programs. In this thesis, we study how graphs and graph transformations can be used to model the static structure and dynamic behavior of object-orientated and service-oriented systems. Our work is mainly motivated by the difficulty in understanding and reasoning about objectorientated and service-oriented programs, which have more sophisticated features compared with traditional procedural programs. We show that the use of graphs and graphs transformations provides both an intuitive visualization and a formal representation of object-orientated and serviceoriented programs with these features, improving people’s understanding of the execution states and behaviors of these programs. We provide a graph-based type system, operational semantics and refinement calculus for an object-oriented language. In this framework, we define class structures and execution states of oo programs as directed and labeled graphs, called class graphs and state graphs, respectively. The type system checks whether a program is well-typed based on its class graph, while the operational semantics defines each step of program execution as a simple graph transformations between state graphs. We show the operational semantics is type-safe in that the execution of a well-typed program does not “go wrong”. Based on the operational semantics, we study the notion of structure refinement of oo programs as graph transformations between their class graphs. We provide a few groups of refinement rules for various purposes such as class expansion and polymorphism elimination and prove their soundness and relative completeness. We also propose a graph-based representation of service-oriented systems specified in a serviceoriented process calculus. In this framework, we define states of service-oriented systems as hier- archical graphs that naturally capture the hierarchical nature of service structures. For this, we exploit a suitable graph algebra and set up a hierarchical graph model, in which graph transformations are studied following the well-known Double-Pushout approach. Based on this model, we provide a graph transformation system with a few sets of graph transformation rules for various purposes such as process copy and process reduction. We prove that the graph transformation system is sound and complete with respect to the reduction semantics of the calculus

Causal Discovery in Physical Systems from Videos

Causal discovery is at the core of human cognition. It enables us to reason about the environment and make counterfactual predictions about unseen scenarios that can vastly differ from our previous experiences. We consider the task of causal discovery from videos in an end-to-end fashion without supervision on the ground-truth graph structure. In particular, our goal is to discover the structural dependencies among environmental and object variables: inferring the type and strength of interactions that have a causal effect on the behavior of the dynamical system. Our model consists of (a) a perception module that extracts a semantically meaningful and temporally consistent keypoint representation from images, (b) an inference module for determining the graph distribution induced by the detected keypoints, and (c) a dynamics module that can predict the future by conditioning on the inferred graph. We assume access to different configurations and environmental conditions, i.e., data from unknown interventions on the underlying system; thus, we can hope to discover the correct underlying causal graph without explicit interventions. We evaluate our method in a planar multi-body interaction environment and scenarios involving fabrics of different shapes like shirts and pants. Experiments demonstrate that our model can correctly identify the interactions from a short sequence of images and make long-term future predictions. The causal structure assumed by the model also allows it to make counterfactual predictions and extrapolate to systems of unseen interaction graphs or graphs of various sizes