64 research outputs found
Imperative Programs as Proofs via Game Semantics
Game semantics extends the Curry-Howard isomorphism to a three-way correspondence: proofs, programs, strategies. But the universe of strategies goes beyond intuitionistic logics and lambda calculus, to capture stateful programs. In this thesis we describe a logical counterpart to this extension, in which proofs denote such strategies. The system is expressive: it contains all of the connectives of Intuitionistic Linear Logic, and first-order quantification. Use of a novel sequoid operator allows proofs with imperative behaviour to be expressed. Thus, we can embed first-order Intuitionistic Linear Logic into this system, Polarized Linear Logic, and an expressive imperative total programming language. We can use the first-order structure to express properties on the imperative programs. The proof system has a tight connection with a simple game model, where games are forests of plays. Formulas are modelled as games, and proofs as history-sensitive winning strategies. We provide a strong full and faithful completeness result with respect to this model: each finitary strategy is the denotation of a unique analytic (cut-free) proof. Infinite strategies correspond to analytic proofs that are infinitely deep. Thus, we can normalise proofs, via the semantics. The proof system makes novel use of the fact that the sequoid operator allows the exponential modality of linear logic to be expressed as a final coalgebra.EThOS - Electronic Theses Online ServiceGBUnited Kingdo
Imperative programs as proofs via game semantics
Game semantics extends the Curry-Howard isomorphism to a three-way
correspondence: proofs, programs, strategies. But the universe of strategies
goes beyond intuitionistic logics and lambda calculus, to capture stateful
programs. In this paper we describe a logical counterpart to this extension, in
which proofs denote such strategies. The system is expressive: it contains all
of the connectives of Intuitionistic Linear Logic, and first-order
quantification. Use of Laird's sequoid operator allows proofs with imperative
behaviour to be expressed. Thus, we can embed first-order Intuitionistic Linear
Logic into this system, Polarized Linear Logic, and an imperative total
programming language.
The proof system has a tight connection with a simple game model, where games
are forests of plays. Formulas are modelled as games, and proofs as
history-sensitive winning strategies. We provide a strong full completeness
result with respect to this model: each finitary strategy is the denotation of
a unique analytic (cut-free) proof. Infinite strategies correspond to analytic
proofs that are infinitely deep. Thus, we can normalise proofs, via the
semantics
Constructing programs or processes
We define interacting sequential programs, motivated originally by constructivist considerations. We use them to investigate notions of implementation and determinism. Process algebras do not define what can be implemented and what cannot. As we demonstrate it is problematic to do so on the set of all processes. Guided by constructivist notions we have constructed interacting sequential programs which we claim can be readily implemented and are a subset of processes
The AutoProof Verifier: Usability by Non-Experts and on Standard Code
Formal verification tools are often developed by experts for experts; as a
result, their usability by programmers with little formal methods experience
may be severely limited. In this paper, we discuss this general phenomenon with
reference to AutoProof: a tool that can verify the full functional correctness
of object-oriented software. In particular, we present our experiences of using
AutoProof in two contrasting contexts representative of non-expert usage.
First, we discuss its usability by students in a graduate course on software
verification, who were tasked with verifying implementations of various sorting
algorithms. Second, we evaluate its usability in verifying code developed for
programming assignments of an undergraduate course. The first scenario
represents usability by serious non-experts; the second represents usability on
"standard code", developed without full functional verification in mind. We
report our experiences and lessons learnt, from which we derive some general
suggestions for furthering the development of verification tools with respect
to improving their usability.Comment: In Proceedings F-IDE 2015, arXiv:1508.0338
- …