1,388 research outputs found

    Notions of Computation and Monads

    Get PDF
    The i.-calculus is considered a useful mathematical tool in the study of programming languages, since programs can be identified with I-terms. However, if one goes further and uses bn-conversion to prove equivalence of programs, then a gross simplification is introduced (programs are identified with total functions from calues to values) that may jeopardise the applicability of theoretical results, In this paper we introduce calculi. based on a categorical semantics for computations, that provide a correct basis for proving equivalence of programs for a wide range of notions of computation

    Extracting total Amb programs from proofs

    Get PDF
    We present a logical system CFP (Concurrent Fixed Point Logic) supporting the extraction of nondeterministic and concurrent programs that are provably total and correct. CFP is an intuitionistic first-order logic with inductive and coinductive definitions extended by two propositional operators: Rrestriction, a strengthening of implication, and an operator for total concurrency. The source of the extraction are formal CFP proofs, the target is a lambda calculus with constructors and recursion extended by a constructor Amb (for McCarthy's amb) which is interpreted operationally as globally angelic choice and is used to implement nondeterminism and concurrency. The correctness of extracted programs is proven via an intermediate domain-theoretic denotational semantics. We demonstrate the usefulness of our system by extracting a nondeterministic program that translates infinite Gray code into the signed digit representation. A noteworthy feature of CFP is the fact that the proof rules for restriction and concurrency involve variants of the classical law of excluded middle that would not be interpretable computationally without Amb.Comment: 39 pages + 4 pages appendix. arXiv admin note: text overlap with arXiv:2104.1466

    Delayed choice : an operator for joining Message Sequence Charts

    Get PDF

    Ups and downs of type theory

    Get PDF

    From Operational Semantics to Abstract Machines

    Get PDF
    We consider the problem of mechanically constructing abstract machines from operational semantics, producing intermediate-level specifications of evaluators guaranteed to be correct with respect to the operational semantics. We construct these machines by repeatedly applying correctness-preserving transformations to operational semantics until the resulting specifications have the form of abstract machines. Though not automatable in general, this approach to constructing machine implementations can be mechanized, providing machine-verified correctness proofs. As examples we present the transformation of specifications for both call-by-name and call-by-value evaluation of the untyped λ-calculus into abstract machines that implement such evaluation strategies. We also present extensions to the call-by-value machine for a language containing constructs for recursion, conditionals, concrete data types, and built-in functions. In all cases, the correctness of the derived abstract machines follows from the (generally transparent) correctness of the initial operational semantic specification and the correctness of the transformations applied

    infinite states verification in game-theoretic logics

    Get PDF
    Many practical problems where the environment is not in the system's control such as service orchestration and contingent and multi-agent planning can be modelled in game-theoretic logics. This thesis demonstrates that the verification techniques based on regression and fixpoint approximation introduced in De Giacomo, Lesperance and Pearce [DLP10] do work on several game-theoretic problems. De Giacomo, Lesperance and Pearce [DLP10] emphasize that their study is essentially theoretical and call for complementing their work with experimental studies to understand whether these techniques are effective in practical cases. Several example problems with varying properties have been developed and, although not exhaustive nor complete,, our results nevertheless demonstrate that the techniques work on some problems. Our results show that the methods introduced in [DLP10] work for infinite domains where very few verification methods are available and allow reasoning about a wide range of game problems. Our examples also demonstrate the use of a rich language for specifying temporal properties proposed in [DLP10]. While classical model checking is well known and utilized, it is mostly restricted to finite-state models. A important aspect of the work is the demonstration of the use and effectiveness of characteristic graphs (ClaBen and Lakemeyer [CL08]) in verifying properties of games in infinite domains. A special-purpose programming language GameGolog proposed in De Giacomo, Lesperance and Pearce [DLP10] allows such game-theoretic systems to be specified procedurally at a high-level of abstraction. We show its practicality to model game structures in a convenient way that combines declarative and procedural elements. We provided examples to show the verification of GameGolog specifications using characteristic graphs. This thesis also proposes a refinement to the formalism in [DLP10] to incorporate action constraints as a mechanism to incorporate user strategies and for the modeller to supply heuristic guidance in temporal property verification. It also presents an implementation of evaluation-based fixpoint verifier that handles Situation Calculus game structures, as well as GameGolog specifications, for temporal property verification in the initial or a given situation. The verifier supports player action constraints

    Implementing Theorem Provers in Logic Programming

    Get PDF
    Logic programming languages have many characteristics that indicate that they should serve as good implementation languages for theorem provers. For example, they are based on search and unification which are also fundamental to theorem proving. We show how an extended logic programming language can be used to implement theorem provers and other aspects of proof systems for a variety of logics. In this language first-order terms are replaced with simply-typed λ-terms, and thus unification becomes higher-order unification. Also, implication and universal quantification are allowed in goals. We illustrate that inference rules can be very naturally specified, and that the primitive search operations of this language correspond to those needed for searching for proofs. We argue on several levels that this extended logic programming language provides a very suitable environment for implementing tactic style theorem provers. Such theorem provers provide extensive capabilities for integrating techniques for automated theorem proving into an interactive proof environment. We are also concerned with representing proofs as objects. We illustrate how such objects can be constructed and manipulated in the logic programming setting. Finally, we propose extensions to tactic style theorem provers in working toward the goal of developing an interactive theorem proving environment that provides a user with many tools and techniques for building and manipulating proofs, and that integrates sophisticated capabilities for automated proof discovery. Many of the theorem provers we present have been implemented in the higher-order logic programming language λProlog
    corecore