A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2017; you can also visit the original URL.
The file type is `application/pdf`

.

## Filters

##
###
Higher-Order Separation Logic in Isabelle/HOLCF

2008
*
Electronical Notes in Theoretical Computer Science
*

We formalize

doi:10.1016/j.entcs.2008.10.022
fatcat:dxrjw4q46nfmvk2k6rkgq7z7pi
*higher*-*order**separation**logic*for a first-*order*imperative language with procedures and local variables*in**Isabelle*/*HOLCF*. ... The*higher*-*order**logic*ensures that we can show non-trivial algorithms correct without having to extend the semantics of the language as was done previously*in*verifications based on first-*order**separation*...*In*[1]*higher*-*order**separation**logic*was proposed. ...##
###
Axiomatic Constructor Classes in Isabelle/HOLCF
[chapter]

2005
*
Lecture Notes in Computer Science
*

We have definitionally extended

doi:10.1007/11541868_10
fatcat:saqpeqvxtrd5fbgtkzgds5dqsu
*Isabelle*/*HOLCF*to support axiomatic Haskell-style constructor classes. ...*Isabelle*/*HOLCF*. ... Background Isabelle is a generic interactive theorem prover, which can be instantiated with various kinds of object-*logics*. Isabelle/HOL is an instantiation of*higher**order**logic*. ...##
###
The Isabelle Framework
[chapter]

2008
*
Lecture Notes in Computer Science
*

Other notable object-

doi:10.1007/978-3-540-71067-7_7
fatcat:y75g4zyzmjdgbkmosmujtq7yra
*logics*are Isabelle/ZF (Zermelo-Fraenkel set-theory, see [34, 36] ) and*Isabelle*/*HOLCF*[26] (Scott's domain theory within HOL). ... Specification Mechanisms Isabelle/Pure is a minimal version of*higher*-*order**logic*; object-*logics*are specified by stating their characteristic rules as new axioms. ... The basic framework is centered around*higher*-*order*unification. The Simplifier supports*higher*-*order*rewriting, with plug-*in*interfaces for extra simplification procedures written*in*ML. ...##
###
Formal Verification of Monad Transformers
[article]

2012
*
arXiv
*
pre-print

We do not require a

arXiv:1207.3208v1
fatcat:4i25rjaosncsdftbfndlyv75ci
*logic*with first-class type constructors, first-class polymorphism, or type quantification; instead, we rely on a domain-theoretic model of the type system*in*a universal domain to ... These ideas are implemented*in*the Tycon library for the Isabelle theorem prover, which builds on the HOLCF library of domain theory. ... Acknowledgments Thanks to John Matthews for many discussions about HOLCF which helped to develop the ideas*in*this paper. ...##
###
Separation logic for sequential programs (functional pearl)

2020
*
Proceedings of the ACM on Programming Languages (PACMPL)
*

This paper presents a simple mechanized formalization of

doi:10.1145/3408998
fatcat:do7vjcwo2rc4pmqpdcnq6leshy
*Separation**Logic*for sequential programs. ... This formalization is aimed for teaching the ideas of*Separation**Logic*, including its soundness proof and its recent enhancements. ... Varming and Birkedal [2008] demonstrate the possibility to formalize*higher*-*order**Separation**Logic*as a shallow embedding*in**Isabelle*/*HOLCF*. ...##
###
ALICE: An Advanced Logic for Interactive Component Engineering
[article]

2014
*
arXiv
*
pre-print

This paper presents an overview of the verification framework ALICE

arXiv:1410.4381v1
fatcat:qb533mr6pbdgtojikbafje4tbi
*in*its current version 0.7. It is based on the generic theorem prover Isabelle [Pau03a]. ... The behavior of a component is generally described as a relation on the observations*in*form of streams of messages flowing over its input and output channels. ... ALICE is embedded*in*the*higher**order**logic*HOL, which itself is formalized using the Isabelle generic theorem prover. ...##
###
Partiality and recursion in interactive theorem provers – an overview

2014
*
Mathematical Structures in Computer Science
*

We focus on theorem provers based on constructive type theory (

doi:10.1017/s0960129514000115
fatcat:y3gdgilgd5bvlev3haw4l3fyxi
*in*particular, Agda and Coq) and*higher*-*order**logic*(*in*particular Isabelle/HOL). ... Other systems and*logics*are covered to a certain extent, but not exhaustively. ...*Higher*-*Order**Logic**In*what follows, we introduce*higher*-*order**logic*(HOL), which we will use to describe the techniques that require classical reasoning. ...##
###
Imperative Functional Programming with Isabelle/HOL
[chapter]

2008
*
Lecture Notes in Computer Science
*

Imperative language features have previously been embedded

doi:10.1007/978-3-540-71067-7_14
fatcat:lcedkeoly5fzxol5ttbj6ezv24
*in**higher**order**logic*via a state monad [7, 14] . ... A more pragmatic option is to store only a representable subset of the full function space*in*the heap, for example just the continuous functions as is done*in**Isabelle*/*HOLCF*[8] . ...##
###
HasCasl: Integrated higher-order specification and program development

2009
*
Theoretical Computer Science
*

,

doi:10.1016/j.tcs.2008.11.020
fatcat:fvluuyjf7ra2dk2izvb2br4uou
*in*particular but not exclusively*in*modern functional programming languages, and as an expressive standard language for*higher*-*order**logic*. ... is both a generalisation of classical*higher*-*order**logic*and can be used as a specification*logic*for Haskell programs. ...*higher**order**logic*. ...##
###
The Design of a Practical Proof Checker for a Lazy Functional Language
[chapter]

2013
*
Lecture Notes in Computer Science
*

Pure, lazy functional languages like Haskell provide a sound basis for formal reasoning about programs

doi:10.1007/978-3-642-40447-4_8
fatcat:atmr7h7rmrg7tc4y5qn45ltsru
*in*an equational style.*In*practice, however, equational reasoning is underutilized. ... MProver features first-class support for reasoning about potentially undefined computations (particularly important*in*a lazy setting), and an extended notion of Haskell-like type classes, enabling a highly ... Type classes originated*in*Haskell [23] as a means of enabling ad-hoc polymorphism, and the idea has been reimplemented*in*Coq [19] and*Isabelle*/*HOLCF*[11] . ...##
###
History of Interactive Theorem Proving
[chapter]

2014
*
Handbook of the History of Logic
*

ACKNOWLEDGEMENTS The authors are grateful to Jörg Siekmann for inviting them to prepare this chapter and for his patience

doi:10.1016/b978-0-444-51624-4.50004-6
fatcat:sngnxnl3ivectj5taj3dgsaa7m
*in*the face of our lengthy delays. ... Gordon modified Cambridge LCF to support classical*higher**order**logic*, and so HOL (for*Higher**Order**Logic*) was born. ... ) • Constructive type theory (Coq, NuPRL) • First-*order*set theory (Mizar, EVES, Isabelle/ZF) •*Logics*of partial terms (LCF, IMPS,*Isabelle*/*HOLCF*) Some of this diversity arises because of specific philosophical ...##
###
Model-Based Engineering for Avionics: Will Specification and Formal Verification e.g. Based on Broy's Streams Become Feasible?

2019
*
Software Engineering
*

This again raises the question, whether developing software the same way as we did the last 30 years is still appropriate, or

dblp:conf/se/KriebelRRS19
fatcat:zna7toi2jzhjpa2oq425gmw52q
*in*the times of much better formal methods and cheap and powerful computational ... capabilities, it would be feasible to use clear and model-based specification techniques for an integrated systems engineering approach and formally verify any physical and*logical*implementation of functionality ... All above mentioned domain-theoretical concepts has been formalized*in*the theorem prover*Isabelle*/*HOLCF*(HOL stands for*higher*-*order**logic*, CF stands for computable functions)*in*[33] , [34] and [ ...##
###
Consistent graphical specification of distributed systems
[chapter]

1997
*
Lecture Notes in Computer Science
*

We show how such an indirect approach can be incorporated

doi:10.1007/3-540-63533-5_7
fatcat:f6dkfjkzbvbyfnsxo6nwjd2rtu
*in*a CASE tool prototype by basing it upon formally defined hierarchical description techniques. ... Since these notions are used*in*the*Isabelle**HOLCF*-implementation of Focus, a corresponding notion of equivalence and refinement has to be defined for STDs using the relational µ calculus. ... Definition of Consistency Conditions*In*AUTOFOCUS, the actual conditions upon which consistency checks are based, are defined using a declarative textual notation, similar to first*order*predicate*logic*...##
###
Partial type constructors: or, making ad hoc datatypes less ad hoc

2019
*
Proceedings of the ACM on Programming Languages (PACMPL)
*

., requiring computable equality or

doi:10.1145/3371108
fatcat:xz7nreyxjrftrcxxrudsy3fuwy
*ordering*functions) to type families with defining equations only over certain choices of arguments. ... experimental analysis of a body of Haskell code, using a proof-of-concept implementation of our system; while there are cases where our system requires additional annotations, these cases are rarely encountered*in*... This material is based*in*part upon work supported by the National Science Foundation under Grant No. CCF-1704041 and Grant No. CNS-1422979. ...##
###
Witnessing (Co)datatypes
[chapter]

2015
*
Lecture Notes in Computer Science
*

Here we describe a complete procedure for deriving nonemptiness witnesses

doi:10.1007/978-3-662-46669-8_15
fatcat:fl3y3sxomfbq5eunt3tvtem7oa
*in*the general mutually recursive, nested case-nonemptiness being a proviso for introducing new types*in**higher*-*order**logic*. ... General Terms Algorithms, Theory, Verification Keywords (Co)datatypes,*higher*-*order**logic*, interactive theorem proving, Isabelle/HOL, category theory datatype (α, β) tree = Leaf β | Branch ((α + (α, β) ... Conventions We work informally*in*a mathematical universe S of sets but adopt many conventions from*higher*-*order**logic*and functional programming. ...
« Previous

*Showing results 1 — 15 out of 19 results*