Abstract State

14,000,000 Leading Edge Experts on the ideXlab platform

Scan Science and Technology

Contact Leading Edge Experts & Companies

Scan Science and Technology

Contact Leading Edge Experts & Companies

The Experts below are selected from a list of 6192 Experts worldwide ranked by ideXlab platform

Yuri Gurevich - One of the best experts on this subject based on the ideXlab platform.

  • Abstract State Machines - Investigating Java Concurrency Using Abstract State Machines
    Lecture Notes in Computer Science, 2020
    Co-Authors: Yuri Gurevich, Wolfram Schulte, Charles Wallace
    Abstract:

    We present a mathematically precise, platform-independent model of Java concurrency using the Abstract State Machine method. We cover all aspects of Java threads and synchronization, gradually adding details to the model in a series of steps. We motivate and explain each concurrency feature, and point out subtleties, inconsistencies and ambiguities in the official, informal Java specification.

  • Abstract State Machines - Abstract State Machines and Computationally Complete Query Languages
    Lecture Notes in Computer Science, 2020
    Co-Authors: Andreas Blass, Yuri Gurevich, Jan Van Den Bussche
    Abstract:

    Abstract State machines (ASMs) form a relatively new computation model holding the promise that they can simulate any computational system in lockstep. In particular, an instance of the ASM model has recently been introduced for computing queries to relational databases. This model, to which we refer as the BGS model, provides a powerful query language in which all computable queries can be expressed. In this paper, we show that when one is only interested in polynomial-time computations, BGS is strictly more powerful than both QL and whilenew, two well-known computationally complete query languages. We then show that when a language such as whilenew is extended with a duplicate elimination mechanism, polynomial-time simulations between the language and BGS become possible.

  • Abstract State Machines - Using Abstract State Machines at Microsoft: A Case Study
    Lecture Notes in Computer Science, 2020
    Co-Authors: Mike Barnett, Egon Börger, Yuri Gurevich, Wolfram Schulte, Margus Veanes
    Abstract:

    Our goal is to provide a rigorous method, clear notation and convenient tool support for high-level system design and analysis. For this purpose we use Abstract State machines (ASMs). Here we describe a particular case study: modeling a debugger of a stack based runtime environment. The study provides evidence for ASMs being a suitable tool for building executable models of software systems on various Abstraction levels, with precise refinement relationships connecting the models. High level ASM models of proposed or existing programs can be used throughout the software development cycle. In particular, ASMs can be used to model inter component behavior on any desired level of detail. This allows one to specify application programming interfaces more precisely than it is done currently.

  • interactive small step algorithms ii Abstract State machines and the characterization theorem
    Logical Methods in Computer Science, 2007
    Co-Authors: Andreas Blass, Yuri Gurevich, Dean Rosenzweig, Benjamin Rossman
    Abstract:

    In earlier work, the Abstract State Machine Thesis -- that arbitrary algorithms are behaviorally equivalent to Abstract State machines -- was established for several classes of algorithms, including ordinary, interactive, small-step algorithms. This was accomplished on the basis of axiomatizations of these classes of algorithms. In Part I (Interactive Small-Step Algorithms I: Axiomatization), the axiomatization was extended to cover interactive small-step algorithms that are not necessarily ordinary. This means that the algorithms (1) can complete a step without necessarily waiting for replies to all queries from that step and (2) can use not only the environment's replies but also the order in which the replies were received. In order to prove the thesis for algorithms of this generality, we extend here the definition of Abstract State machines to incorporate explicit attention to the relative timing of replies and to the possible absence of replies. We prove the characterization theorem for extended Abstract State machines with respect to general algorithms as axiomatized in Part I.

  • Can Abstract State machines be useful in language theory
    Theoretical Computer Science, 2007
    Co-Authors: Yuri Gurevich, Margus Veanes, Charles Wallace
    Abstract:

    The Abstract State machine (ASM) is a modern computation model. ASMs and ASM based tools are used in academia and industry, albeit on a modest scale. They allow you to give high-level operational semantics to computer artifacts and to write executable specifications of software and hardware at the desired Abstraction level. In connection with the 2006 conference on Developments in Language Theory, we point out several ways that we believe Abstract State machines can be useful to the DLT community.

Klaus-dieter Schewe - One of the best experts on this subject based on the ideXlab platform.

  • The Evolution of Conceptual Modeling - Composing Personalised Services on top of Abstract State Services
    2020
    Co-Authors: Hui Ma, Klaus-dieter Schewe, Bernhard Thalheim, Qing Wang
    Abstract:

    We introduce Abstract State Services (ASSs) as an Abstraction of data-intensive services that can be made available for use by other systems, e.g. via the web. An ASS combines a hidden database layer with an operation-equipped view layer, and can be anything from a simple function to a full-fledged Web Information System or a Data Warehouse. We adopt the fundamental approach of Abstract State Machines to model ASSs. Then we show how tailored services can be extracted from available ASSs, integrated with other ASSs and personalised to user preferences.

  • BSP Abstract State machines capture bulk synchronous parallel computations
    Science of Computer Programming, 2019
    Co-Authors: Flavio Ferrarotti, Senén González, Klaus-dieter Schewe
    Abstract:

    Abstract The bulk synchronous parallel (BSP) bridging model is a model for concurrent computations with alternating computation and communication phases between programs running on different processors. In a computation phase the programs proceed independently and asynchronously until a barrier is reached. In a communication phase initiated by all programs having reached the barrier only messages between the programs are exchanged until normal processing can be continued. In this article we present a behavioural theory for BSP computations comprising an axiomatisation of the BSP model, the definition of a restricted class of concurrent Abstract State machines, which we call BSP Abstract State machines, and the proof that BSP Abstract State machines capture BSP computations as defined by the axiomatisation. We illustrate the use of BSP Abstract State machines on map-reduce.

  • ABZ - Abstract State Machines with Exact Real Arithmetic
    Lecture Notes in Computer Science, 2018
    Co-Authors: Christoph Beierle, Klaus-dieter Schewe
    Abstract:

    Type-2 Theory of Effectivity is a well established theory of computability on infinite strings, which in this paper is exploited to define a data type \( Real \) as part of the background structure of Abstract State Machines. Real numbers are represented by rapidly converging Cauchy sequences, on top of which standard operations such as addition, multiplication, division, exponentials, trigonometric functions, etc. can be defined. In this way exact computation with real numbers is enabled. Output can be generated at any degree of precision by exploring only sufficiently long prefixes of the representing Cauchy sequences.

  • SYNASC - Concurrent Reflective Abstract State Machines
    2017 19th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing (SYNASC), 2017
    Co-Authors: Klaus-dieter Schewe
    Abstract:

    The core of a distributed system can be characterised by autonomously acting agents, where each agent executes its own program, uses shared resources and communicates with the others, but otherwise is totally oblivious to the behaviour of the other agents. In a distributed adaptive system (DAS) agents may change their programs, enter or leave the collection at any time thereby changing the behaviour of the overall system. The behavioural theory of DAS provides an axiomatic definition plus a proof that concurrent reflective Abstract State machines (crASMs) captures all systems stipulated by the axioms. In this paper we take a closer look into crASMs emphasising the tree background structure that is needed for handling the manipulation of self-representations.

  • a logic for non deterministic parallel Abstract State machines
    arXiv: Logic in Computer Science, 2017
    Co-Authors: Flavio Ferrarotti, Klaus-dieter Schewe, Qing Wang
    Abstract:

    We develop a logic which enables reasoning about single steps of non-deterministic parallel Abstract State Machines (ASMs). Our logic builds upon the unifying logic introduced by Nanchen and St\"ark for reasoning about hierarchical (parallel) ASMs. Our main contribution to this regard is the handling of non-determinism (both bounded and unbounded) within the logical formalism. Moreover, we do this without sacrificing the completeness of the logic for Statements about single steps of non-deterministic parallel ASMs, such as invariants of rules, consistency conditions for rules, or step-by-step equivalence of rules.

Margus Veanes - One of the best experts on this subject based on the ideXlab platform.

  • Abstract State Machines - Using Abstract State Machines at Microsoft: A Case Study
    Lecture Notes in Computer Science, 2020
    Co-Authors: Mike Barnett, Egon Börger, Yuri Gurevich, Wolfram Schulte, Margus Veanes
    Abstract:

    Our goal is to provide a rigorous method, clear notation and convenient tool support for high-level system design and analysis. For this purpose we use Abstract State machines (ASMs). Here we describe a particular case study: modeling a debugger of a stack based runtime environment. The study provides evidence for ASMs being a suitable tool for building executable models of software systems on various Abstraction levels, with precise refinement relationships connecting the models. High level ASM models of proposed or existing programs can be used throughout the software development cycle. In particular, ASMs can be used to model inter component behavior on any desired level of detail. This allows one to specify application programming interfaces more precisely than it is done currently.

  • Can Abstract State machines be useful in language theory
    Theoretical Computer Science, 2007
    Co-Authors: Yuri Gurevich, Margus Veanes, Charles Wallace
    Abstract:

    The Abstract State machine (ASM) is a modern computation model. ASMs and ASM based tools are used in academia and industry, albeit on a modest scale. They allow you to give high-level operational semantics to computer artifacts and to write executable specifications of software and hardware at the desired Abstraction level. In connection with the 2006 conference on Developments in Language Theory, we point out several ways that we believe Abstract State machines can be useful to the DLT community.

  • generating finite State machines from Abstract State machines
    International Symposium on Software Testing and Analysis, 2002
    Co-Authors: Wolfgang Grieskamp, Yuri Gurevich, Wolfram Schulte, Margus Veanes
    Abstract:

    We give an algorithm that derives a finite State machine (FSM) from a given Abstract State machine (ASM) specification. This allows us to integrate ASM specs with the existing tools for test case generation from FSMs. ASM specs are executable but have typically too many, often infinitely many States. We group ASM States into finitely many hyperStates which are the nodes of the FSM. The links of the FSM are induced by the ASM State transitions.

  • ISSTA - Generating finite State machines from Abstract State machines
    Proceedings of the international symposium on Software testing and analysis - ISSTA '02, 2002
    Co-Authors: Wolfgang Grieskamp, Yuri Gurevich, Wolfram Schulte, Margus Veanes
    Abstract:

    We give an algorithm that derives a finite State machine (FSM) from a given Abstract State machine (ASM) specification. This allows us to integrate ASM specs with the existing tools for test case generation from FSMs. ASM specs are executable but have typically too many, often infinitely many States. We group ASM States into finitely many hyperStates which are the nodes of the FSM. The links of the FSM are induced by the ASM State transitions.

Egon Börger - One of the best experts on this subject based on the ideXlab platform.

  • Abstract State Machines - Abstract State Machines
    Java and the Java Virtual Machine, 2020
    Co-Authors: Robert F. Stärk, Joachim Schmid, Egon Börger
    Abstract:

    The notion of Abstract State Machines (ASMs), defined in [20], captures in mathematically rigorous yet transparent form some fundamental operational intuitions of computing, and the notation is familiar from programming practice and mathematical standards. This allows the practitioner to work with ASMs without any further explanation, viewing them as `pseudocode over Abstract data’ which comes with a well defined semantics supporting the intuitive understanding. We therefore suggest to skip this chapter and to come back to it only should the need be felt upon further reading.

  • Abstract State Machines - Using Abstract State Machines at Microsoft: A Case Study
    Lecture Notes in Computer Science, 2020
    Co-Authors: Mike Barnett, Egon Börger, Yuri Gurevich, Wolfram Schulte, Margus Veanes
    Abstract:

    Our goal is to provide a rigorous method, clear notation and convenient tool support for high-level system design and analysis. For this purpose we use Abstract State machines (ASMs). Here we describe a particular case study: modeling a debugger of a stack based runtime environment. The study provides evidence for ASMs being a suitable tool for building executable models of software systems on various Abstraction levels, with precise refinement relationships connecting the models. High level ASM models of proposed or existing programs can be used throughout the software development cycle. In particular, ASMs can be used to model inter component behavior on any desired level of detail. This allows one to specify application programming interfaces more precisely than it is done currently.

  • Concurrent Abstract State machines
    Acta Informatica, 2016
    Co-Authors: Egon Börger, Klaus-dieter Schewe
    Abstract:

    A concurrent Abstract State Machine (ASM) is a family of agents each equipped with a sequential ASM to execute. We define the semantics of concurrent ASMs by concurrent ASM runs which overcome the problems of Gurevich’s distributed ASM runs and generalize Lamport’s sequentially consistent runs. A postulate characterizing an intuitive understanding of concurrency is formulated. It allows us to State and prove an extension of the sequential ASM thesis to a concurrent ASM thesis.

  • ABZ - Modeling Distributed Algorithms by Abstract State Machines Compared to Petri Nets
    Lecture Notes in Computer Science, 2016
    Co-Authors: Egon Börger
    Abstract:

    We show how to model distributed algorithms by Abstract State Machines ASMs. Comparing these models with Petri nets PNs reveals a certain number of idiosyncrasies of PNs which complicate both model design and analysis. The ASMs we define illustrate how one can avoid such framework related technicalities.

  • ambient Abstract State machines with applications
    Journal of Computer and System Sciences, 2012
    Co-Authors: Egon Börger, Antonio Cisternino, Vincenzo Gervasi
    Abstract:

    We define a flexible Abstract ambient concept which turned out to support current programming practice, in fact can be instantiated to apparently any environment paradigm in use in frameworks for distributed computing with heterogeneous components. For the sake of generality and to also support rigorous high-level system design practice we give the definition in terms of Abstract State Machines. We show the definition to uniformly capture the common static and dynamic disciplines for isolating States or concurrent behavior (e.g. handling of multiple threads for Java) as well as for sharing memory, patterns of object-oriented programming (e.g. for delegation, incremental refinement, encapsulation, views) and agent mobility.

Andreas Blass - One of the best experts on this subject based on the ideXlab platform.

  • Abstract State Machines - Abstract State Machines and Pure Mathematics
    Lecture Notes in Computer Science, 2020
    Co-Authors: Andreas Blass
    Abstract:

    We discuss connections, similarities, and differences between the concepts and issues arising in the study of Abstract State machines and those arising in pure mathematics, particularly in set theory and logic. Among the topics from pure mathematics are the foundational role of set theory, permutation models of set theory without the axiom of choice, and interpretations (between theories or vocabularies) regarded as transformations acting on structures.

  • Abstract State Machines - Abstract State Machines and Computationally Complete Query Languages
    Lecture Notes in Computer Science, 2020
    Co-Authors: Andreas Blass, Yuri Gurevich, Jan Van Den Bussche
    Abstract:

    Abstract State machines (ASMs) form a relatively new computation model holding the promise that they can simulate any computational system in lockstep. In particular, an instance of the ASM model has recently been introduced for computing queries to relational databases. This model, to which we refer as the BGS model, provides a powerful query language in which all computable queries can be expressed. In this paper, we show that when one is only interested in polynomial-time computations, BGS is strictly more powerful than both QL and whilenew, two well-known computationally complete query languages. We then show that when a language such as whilenew is extended with a duplicate elimination mechanism, polynomial-time simulations between the language and BGS become possible.

  • interactive small step algorithms ii Abstract State machines and the characterization theorem
    Logical Methods in Computer Science, 2007
    Co-Authors: Andreas Blass, Yuri Gurevich, Dean Rosenzweig, Benjamin Rossman
    Abstract:

    In earlier work, the Abstract State Machine Thesis -- that arbitrary algorithms are behaviorally equivalent to Abstract State machines -- was established for several classes of algorithms, including ordinary, interactive, small-step algorithms. This was accomplished on the basis of axiomatizations of these classes of algorithms. In Part I (Interactive Small-Step Algorithms I: Axiomatization), the axiomatization was extended to cover interactive small-step algorithms that are not necessarily ordinary. This means that the algorithms (1) can complete a step without necessarily waiting for replies to all queries from that step and (2) can use not only the environment's replies but also the order in which the replies were received. In order to prove the thesis for algorithms of this generality, we extend here the definition of Abstract State machines to incorporate explicit attention to the relative timing of replies and to the possible absence of replies. We prove the characterization theorem for extended Abstract State machines with respect to general algorithms as axiomatized in Part I.

  • Abstract State machines capture parallel algorithms
    ACM Transactions on Computational Logic, 2003
    Co-Authors: Andreas Blass, Yuri Gurevich
    Abstract:

    We give an axiomatic description of parallel, synchronous algorithms. Our main result is that every such algorithm can be simulated, step for step, by an Abstract State machine with a background that provides for multisets.

  • Abstract State machines and computationally complete query languages
    Information & Computation, 2002
    Co-Authors: Andreas Blass, Yuri Gurevich, Jan Van Den Bussche
    Abstract:

    Abstract State machines (ASMs) form a relatively new computation model holding the promise that they can simulate any computational system in lockstep. In particular, an instance of the ASM model has recently been introduced for computing queries to relational databases. This model, to which we refer as the BGS model, provides a powerful query language in which all computable queries can be expressed. In this paper, we show that when one is only interested in polynomial- time computations, BGS is strictly more powerful than both QL and whilenew, two well-known computationally complete query languages. We then show that when a language such as whilenew is extended with a duplicate elimination mechanism, polynomial-time simulations between the language and BGS become possible. Copyright 2002 Elsevier Science (USA).