69 research outputs found

    Planning problems as types, plans as programs : a dependent types infrastructure for verification and reasoning about automated plans in Agda

    Get PDF
    Historically, the Artificial Intelligence and programming language fields have had a mutually beneficial relationship. Typically, theoretical results in the programming language field have practical utility in the Artificial Intelligence field. One example of this that has roots in both declarative languages and theorem proving is AI planning. In recent years, new programming languages have been developed that are founded on dependent type theory. These languages are not only more expressive than traditional programming languages but also have the ability to represent and prove mathematical properties within the language. This thesis will explore how dependently typed languages can benefit the AI planning field. On one side this thesis will show how AI planning languages can be enriched with more expressivity and stronger verification guarantees. On the other, it will show that AI planning is an ideal field to illustrate the practical utility of largely theoretical aspects of programming language theory. This thesis will accomplish this by implementing multiple inference systems for plan validation in the dependently-typed programming language Agda. Importantly, these inference systems will be automated, and embody the Curry-Howard correspondence where plans will not only be proof-terms but also executable functions. This thesis will then show how the dependently-typed implementations of the inference systems can be further utilised to add enriched constraints over plan validation

    24th Nordic Conference on Computational Linguistics (NoDaLiDa)

    Get PDF

    Proof-theoretic Semantics for Intuitionistic Multiplicative Linear Logic

    Get PDF
    This work is the first exploration of proof-theoretic semantics for a substructural logic. It focuses on the base-extension semantics (B-eS) for intuitionistic multiplicative linear logic (IMLL). The starting point is a review of Sandqvist’s B-eS for intuitionistic propositional logic (IPL), for which we propose an alternative treatment of conjunction that takes the form of the generalized elimination rule for the connective. The resulting semantics is shown to be sound and complete. This motivates our main contribution, a B-eS for IMLL , in which the definitions of the logical constants all take the form of their elimination rule and for which soundness and completeness are established

    Tools and Algorithms for the Construction and Analysis of Systems

    Get PDF
    This open access book constitutes the proceedings of the 28th International Conference on Tools and Algorithms for the Construction and Analysis of Systems, TACAS 2022, which was held during April 2-7, 2022, in Munich, Germany, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022. The 46 full papers and 4 short papers presented in this volume were carefully reviewed and selected from 159 submissions. The proceedings also contain 16 tool papers of the affiliated competition SV-Comp and 1 paper consisting of the competition report. TACAS is a forum for researchers, developers, and users interested in rigorously based tools and algorithms for the construction and analysis of systems. The conference aims to bridge the gaps between different communities with this common interest and to support them in their quest to improve the utility, reliability, exibility, and efficiency of tools and algorithms for building computer-controlled systems

    Bounded Verification of Message-Passing Concurrency in Go

    Get PDF
    Go is a programming language that has gained increased popularity due to its good support for system programming and its channel-based message passing concurrency mechanism. These features rendered Go the language of choice of many platform software developers. Go offers a wide range of primitives to coordinate lightweight threads, e.g., channels, waitgroups, and mutexes. Although, these concurrency primitives help mitigate data races, they introduce additional complications due to the complexity of reasoning about concurrency. In this thesis, we first perform an empirical analysis on concurrent Go programs which analyses 125 Go projects from GitHub in order to understand how concurrency is used in publicly available code. Our results include the following findings: (1) concurrency primitives are used frequently and intensively, (2) most projects use synchronous communication channels over asynchronous ones, and (3) most Go projects use simple concurrent thread topologies, which are however currently not fully supported by existing static verification frameworks. To address these limitations, we propose a novel static checker for Go programs that relies on performing bounded model checking of their concurrent behaviours. In contrast to previous works, our approach deals with large codebases, supports programs that have statically unknown parameters and is extensible to additional concurrency primitives. Our work includes an empirical analysis that studies the usage of concurrency in Go projects, a detailed presentation of the extraction algorithm from Go programs to Promela models, an algorithm to automatically check programs with statically unknown parameters, and a large scale evaluation of our approach. The latter shows that our approach outperforms the state-of-the-art

    Programming Languages and Systems

    Get PDF
    This open access book constitutes the proceedings of the 31st European Symposium on Programming, ESOP 2022, which was held during April 5-7, 2022, in Munich, Germany, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022. The 21 regular papers presented in this volume were carefully reviewed and selected from 64 submissions. They deal with fundamental issues in the specification, design, analysis, and implementation of programming languages and systems

    On Reasonable Space and Time Cost Models for the λ-Calculus

    Get PDF
    Slot and van Emde Boas Invariance Thesis states that a time (respectively, space) cost model is reasonable for a computational model C if there are mutual simulations between Turing machines and C such that the overhead is polynomial in time (respectively, linear in space). The rationale is that under the Invariance Thesis, complexity classes such as LOGSPACE, P, PSPACE, become robust, i.e. machine independent. In this dissertation, we want to find out if it possible to define a reasonable space cost model for the lambda-calculus, the paradigmatic model for functional programming languages. We start by considering an unusual evaluation mechanism for the lambda-calculus, based on Girard's Geometry of Interaction, that was conjectured to be the key ingredient to obtain a space reasonable cost model. By a fine complexity analysis of this schema, based on new variants of non-idempotent intersection types, we disprove this conjecture. Then, we change the target of our analysis. We consider a variant over Krivine's abstract machine, a standard evaluation mechanism for the call-by-name lambda-calculus, optimized for space complexity, and implemented without any pointer. A fine analysis of the execution of (a refined version of) the encoding of Turing machines into the lambda-calculus allows us to conclude that the space consumed by this machine is indeed a reasonable space cost model. In particular, for the first time we are able to measure also sub-linear space complexities. Moreover, we transfer this result to the call-by-value case. Finally, we provide also an intersection type system that characterizes compositionally this new reasonable space measure. This is done through a minimal, yet non trivial, modification of the original de Carvalho type system

    Non-Deterministic Abstract Machines

    Get PDF
    We present a generic design of abstract machines for non-deterministic programming languages, such as process calculi or concurrent lambda calculi, that provides a simple way to implement them. Such a machine traverses a term in the search for a redex, making non-deterministic choices when several paths are possible and backtracking when it reaches a dead end, i.e., an irreducible subterm. The search is guaranteed to terminate thanks to term annotations the machine introduces along the way. We show how to automatically derive a non-deterministic abstract machine from a zipper semantics - a form of structural operational semantics in which the decomposition process of a term into a context and a redex is made explicit. The derivation method ensures the soundness and completeness of the machines w.r.t. the zipper semantics

    Analyse statique de transformations pour l'Ă©limination de motifs

    Get PDF
    Program transformation is an extremely common practice in computer science. From compilation to tests generation, through many approaches of code analysis and formal verification of programs, it is a process that is both ubiquitous and critical to properly functioning programs and information systems. This thesis proposes to study the program transformations mechanisms in order to express and verify syntactical guarantees on the behaviour of these transformations and on their results.Giving a characterisation of the shape of terms returned by such a transformation is, indeed, a common approach to the formal verification of programs. In order to express some properties often used by this type of approaches, we propose in this thesis a formalism inspired by themodel of compilation passes, which are used to describe the general compilation of a program as a sequence of minimal transformations, and based on the notions of pattern matching and term rewriting.This formalism relies on an annotation mechanism of function symbols in order to express a set of specifications describing the behaviours of the associated functions. We then propose a static analysis method in order to check that a transformation, expressed as a term rewritesystem, actually verifies its specifications.La transformation de programmes est une pratique trĂšs courante dans le domaine des sciences informatiques. De la compilation Ă  la gĂ©nĂ©ration de test en passant par de nombreuses approches d’analyse de codes et de vĂ©rification formelle des programmes, c’est un procĂ©dĂ© qui est Ă  la fois omniprĂ©sent et crucial au bon fonctionnement des programmes et systĂšmes informatiques. Cette thĂšse propose une Ă©tude formelle des procĂ©dures de transformation de programmes dans le but d’exprimer et de garantir des propriĂ©tĂ©s syntaxiques sur le comportement et les rĂ©sultats d’unetelle transformation.Dans le contexte de la vĂ©rification formelle des programmes, il est en effet souvent nĂ©cessaire de pouvoir caractĂ©riser la forme des termes obtenus par rĂ©duction suivant une telle transformation. En s’inspirant du modĂšle de passes de compilation, qui dĂ©crivent un sĂ©quençage de la compilation d’un programme en Ă©tapes de transformation minimales n’affectant qu’un petit nombre des constructions du langage, on introduit, dans cette thĂšse, un formalisme basĂ© sur les notions de filtrage par motif et de rĂ©Ă©criture permettant de dĂ©crire certaines propriĂ©tĂ©s couramment induites par ce type de transformations.Le formalisme proposĂ© se repose sur un systĂšme d’annotations des symboles de fonction dĂ©crivant une spĂ©cification du comportement attendu des fonctions associĂ©es. On prĂ©sente alors une mĂ©thode d’analyse statique permettant de vĂ©rifier que les transformations Ă©tudiĂ©es, exprimĂ©es par un systĂšme de rĂ©Ă©criture, satisfont en effet ces spĂ©cifications

    Computer Aided Verification

    Get PDF
    This open access two-volume set LNCS 13371 and 13372 constitutes the refereed proceedings of the 34rd International Conference on Computer Aided Verification, CAV 2022, which was held in Haifa, Israel, in August 2022. The 40 full papers presented together with 9 tool papers and 2 case studies were carefully reviewed and selected from 209 submissions. The papers were organized in the following topical sections: Part I: Invited papers; formal methods for probabilistic programs; formal methods for neural networks; software Verification and model checking; hyperproperties and security; formal methods for hardware, cyber-physical, and hybrid systems. Part II: Probabilistic techniques; automata and logic; deductive verification and decision procedures; machine learning; synthesis and concurrency. This is an open access book
    • 

    corecore