Verified Functional Programming in Agda (ACM Books) by Aaron Stump (PDF)

Description

Agda is an advanced programming language based on Type Theory. Agda’s type system is expressive enough to support full functional verification of programs, in two styles. In external verification, we write pure functional programs and then write proofs of properties about them. The proofs are separate external artifacts, typically using structural induction. In internal verification, we specify properties of programs through rich types for the programs themselves. This often necessitates including proofs inside code, to show the type checker that the specified properties hold. The power to prove properties of programs in these two styles is a profound addition to the practice of programming, giving programmers the power to guarantee the absence of bugs, and thus improve the quality of software more than previously possible.Verified Functional Programming in Agda is the first book to provide a systematic exposition of external and internal verification in Agda, suitable for undergraduate students of Computer Science. No familiarity with functional programming or computer-checked proofs is presupposed.The book begins with an introduction to functional programming through familiar examples like booleans, natural numbers, and lists, and techniques for external verification. Internal verification is considered through the examples of vectors, binary search trees, and Braun trees. More advanced material on type-level computation, explicit reasoning about termination, and normalization by evaluation is also included. The book also includes a medium-sized case study on Huffman encoding and decoding.

User’s Reviews

Reviews from Amazon users which were colected at the time this book was published on the website:

⭐This is an excellent book on dependent type programming with Agda. The book doesn’t cover any theory about dependent types, but does an excellent job at explaining how to use Agda for theorem proving. One epidemic among all theorem proving books (including Software Foundations and Chilpila’s book on CoQ) is that they don’t seem to emphasize the big-picture before delving into details (for example, explaining up front that a goal means a data type, that equality type is not the same as equality operator etc.,). This book also suffers from this disease, but it has a fairly large number of simple proofs, which in conjunction with Simon Thompson’s book on Type Theory can fill in the gaps. The other complaint, I have is that book keeps emphasizing that the variable `x` in type is not the same variable `x` while doing pattern matching. It would’ve been better had the author used a different variable naming conventions (e.g., x, y, z for defining dependent function type, and x1, y1, z1 etc. while doing pattern matching, and also describing how type-refinement (i.e., alpha-conversion) in Agda work. I’m giving it four star because of these reasons.

⭐As of May 2019 this is easily the most accessible introduction to using a dependently-typed language, in this case Agda, to prove properties of programs and mathematical theorems in a practical setting. The only possible competitor for a first introduction would be the freely available online book “Software Foundations” by Pierce et. al. which uses Coq, a more complex dependently-typed language environment.After reading “Verified Programming in Agda” interested readers will be prepared to tackle more advanced books including “Type Theory and Formal Proof” by Nederpelt and Geuvers for theory, “Interactive Theorem Proving and Program Development” by Bertot and Casteron for combined theory and practice using Coq, and the more rapidly paced “Certified Programming with Dependent Types” by Chlipala.

⭐excellent book on Agda and the IAL and gratr

⭐This book reads like a series of lecture notes on matters related to programming with dependent types, logic and type theory, using Agda as a tool. It relies on a freely downloadable “library” of theorems and examples used in it. The choice of subjects covered in the chapters is unclear: earlier chapters detail features of the language and how to use Agda with Emacs, with concrete examples. Later chapters, though, give an overview of a wider range of topics, such as proof by reflection, termination, parsing, or Kripke semantics, without much justification about why each was chosen instead of another. Surprisingly, the chapter on parsing makes its main focus to describe how to use an Agda parser generator designed by the author.The book choses a practical approach and does not require previous knowledge of logic or type theory, making it accessible to a wider audience. However, the explanations lack some clarity, some points being repeated several times, and some, although necessary to inexperienced readers, missing. At times they are a paraphrase of the source code presented instead of an explanation. Each chapter comes with simple exercises, but few references to other texts for further study.The page layout of the Kindle version (the only one I purchased) is bad: the indentation of paragraphs is too small; the font for source code is proportional, breaking the much needed alignment between clauses and sub-clauses, sending half of a type declaration to the right of the page, or mingling file names with their source code. The figures are plain images, and scale poorly.In its present state, I can not recommend buying this book. I hope the author finds the time and energy to produce an improved edition.

⭐

Keywords

Free Download Verified Functional Programming in Agda (ACM Books) in PDF format
Verified Functional Programming in Agda (ACM Books) PDF Free Download
Download Verified Functional Programming in Agda (ACM Books) PDF Free
Verified Functional Programming in Agda (ACM Books) PDF Free Download
Download Verified Functional Programming in Agda (ACM Books) PDF
Free Download Ebook Verified Functional Programming in Agda (ACM Books)