1 / 32

An Introduction to Agda

An Introduction to Agda. Curtis Dunham February 1, 2019. Agenda. History Agda What it is Why it’s interesting Some basic definitions and proofs Demo Emacs interaction Typed holes Short proofs. Intuitionistic Type Theory: The Forefathers. Brouwer. Russell. Intuitionism. Types.

sattler
Download Presentation

An Introduction to Agda

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. An Introduction to Agda Curtis Dunham February 1, 2019

  2. Agenda • History • Agda • What it is • Why it’s interesting • Some basic definitions and proofs • Demo • Emacs interaction • Typed holes • Short proofs

  3. Intuitionistic Type Theory:The Forefathers Brouwer Russell Intuitionism Types

  4. Intuitionism • Briefly: mathematics withoutThe Law of the Excluded Middle (LEM) • LEM: All propositions are either true or false;∀ P, P ∨ ¬P. • Demands construction of witnesses:∃x : P(x) can only be proven by constructing anobject x such that P(x).

  5. Russell’s Types • Russell’s Paradox:“the set of all sets that do not contain themselves” • Self-reference is problematic • Types enforce a hierarchy in which self-reference is impossible

  6. BHK Interpretation1 • The Brouwer-Heyting-Kolmogorov Interpretation:interpretation of the logical operators in intuitionistic logic • A ∧ B requires a proof of A and a proof of B • A ∨ B requires a proof of A or a proof of B …

  7. BHK Interpretation2 • A → B requires a construction that transforms any proof of A into a proof of B • i.e. evidence a : A transformed by function fsuch that f(a) : B • ⊥ (absurdity) has no proof • ¬A means A → ⊥

  8. Curry-Howard Correspondence • and ⟺ pairing • or ⟺ tagged union • implication⟺ function application • false/absurdity ⟺ type with no members

  9. Intuitionistic Type Theory • Per Martin-Löf:Martin-Löf Type Theory (MLTT) (1972) Some key contributions towards Agda: • Calculus of Constructions, Coquand • Calculus of Inductive Constructions, Paulin-Mohring • UTT, Luo • Agda 2, Ulf Norell

  10. What is Agda? From the website[1] : • A dependently-typed functional programming language • A proof assistant A product of Sweden – Chalmers, Gothenburg University [1] http://wiki.portal.chalmers.se/agda/

  11. Similar Systems • Coq (CIC), Ocaml • Matita (CIC), Ocaml • Lean (CIC), C++ • Idris, Haskell

  12. Agda and Haskell Agda is… • Written in Haskell • Compiles to Haskell • Liberally borrows Haskell syntax Haskell influence brings: • Fancy lambda calculus with pattern matching • Significant indentation

  13. Normal dependently typed features • Types and terms share hierarchy of universes • Terms in types, types in terms – “full lambda cube” • Type functions • “Propositions as Types”, “Proofs are Programs” • A theorem is the type of its proofs • A proof “proves” the theorem by inhabiting/having the type • Dependent product (Π), dependent sum (Σ) • Constructive “for all” and “there exists” quantifiers • Type inference: arguments can often be inferred

  14. Programming Language or Prover? How? Recall: Agda is both • A dependently-typed functional programming language • A proof assistant In this logical system, type checking = proof checking When using Agda as a prover, programs are not “compiled”; type checking is sufficient.

  15. Distinct features • Interactive editing of typed holes in Emacs • Unicode • Proof terms – deBruijncriterion ✓ • Unlike tactic-oriented provers (e.g. Coq, HOL),in Agda the proof terms are written directly • A brief aside for the next few slides:This attribute receives undeserved negative prejudice

  16. Proof Terms • Back in 2010, Ben Delaware gave a Coq introduction to this audience • He suggested that writing proof terms (as in Agda) is unpleasant e.g. proof of associativity of list append: Definition app_assoc := list_ind (fun a0 : list A => forall b c : list A, a0 ++ b ++ c = (a0 ++ b) ++ c) (fun b c : list A => refl_equal (b ++ c)) (fun (a0 : A) (a1 : list A) (IHa : forall b c : list A, a1 ++ b ++ c = (a1 ++ b) ++ c) (b c : list A) => let H := eq_ind_r (fun l : list A => a0 :: (a1 ++ b) ++ c = a0 :: l) (refl_equal (a0 :: (a1 ++ b) ++ c)) (IHa b c) in eq_ind_r (fun l : list A => a0 :: a1 ++ b ++ c = l) (eq_ind_r (fun l : list A => a0 :: l = a0 :: l) (refl_equal (a0 :: (a1 ++ b) ++ c)) (IHa b c)) H) a

  17. Proof Tactics • But that proofs by tactics was more pleasant e.g. proof script for associativity of list append: Lemma app_assoc : forall A (a b c : list A), a ++ (b ++ c) = (a ++ b) ++ c. induction a; simpl; intros. reflexivity. cut (a :: (a0 ++ b) ++ c = a :: (a0 ++ b ++ c)). intros; rewrite H; rewrite IHa; reflexivity. rewrite IHa; reflexivity. Qed.

  18. Counterpoint • This distinction is true of Coq • Avoid writing Gallina proof terms directly • Ltac (tactic language) is dirty, but expedient • But in Agda … • Writing proofs as Agda functions isn’t so bad… • Typed holes provide equivalent interactivity! Why?

  19. Associativity of append in Agda From the Agda standard library (agda-stdlib): module _ {a} {A : Set a} where ++-assoc : Associative {A = List A} _≡_ _++_ ++-assoc [] yszs = refl ++-assoc (x ∷ xs) yszs = cong(x ∷_) (++-assocxsyszs)

  20. Some Definitional Backchaining… -- Algebra/FunctionProperties.agda module Algebra.FunctionProperties {a ℓ} {A : Set a} (_≈_ : Rel A ℓ) where Associative : Op₂ A → Set _ Associative _∙_ = ∀ x y z → ((x ∙ y) ∙ z) ≈ (x ∙ (y ∙ z)) -- Algebra/FunctionProperties/Core.agda Op₂ : ∀ {ℓ} → Set ℓ → Set ℓ Op₂ A = A → A → A

  21. Definition of ++ (list concatenation) -- Data/List/Base.agda infixr5 _++_ _++_ : ∀ {a} {A : Set a} → List A → List A → List A [] ++ ys = ys (x ∷ xs) ++ ys = x ∷ (xs ++ ys)

  22. Definition of ≡ (equality) -- Agda/Builtin/Equality.agda infix 4 _≡_ data _≡_ {a} {A : Set a} (x : A) : A → Set a where instance refl : x ≡ x

  23. Associativity of append, again1 ++-assoc : Associative {A = List A} _≡_ _++_ ++-assoc [] yszs = refl ++-assoc (x ∷ xs) yszs = cong(x ∷_) (++-assocxsyszs) After applying Associative, the type signature is roughly λ (x y z : List _) → (x ++ y) ++ z ≡ x ++ (y ++ z)

  24. Associativity of append, again2 ++-assoc : Associative {A = List A} _≡_ _++_ ++-assoc[]yszs = refl ++-assoc(x ∷ xs) yszs = cong(x ∷_) (++-assocxsyszs) Proof proceeds by case analysis on the first argument.

  25. Associativity of append, again3 ++-assoc : Associative {A = List A} _≡_ _++_ ++-assoc [] yszs = refl ++-assoc (x ∷ xs) yszs = cong(x ∷_) (++-assocxsyszs) Base case is trivial (‘refl’ means proof by reflexivity): Recall that (by definition of ++), [] ++ ys ≡ ys. So ([] ++ y) ++ z ≡ [] ++ (y ++ z) y ++ z ≡ y ++ z refl (y ++ z)

  26. Associativity of append, again4 ++-assoc : Associative {A = List A} _≡_ _++_ ++-assoc [] yszs = refl ++-assoc (x ∷ xs) yszs = cong(x ∷_) (++-assocxsyszs) When using proof by induction, the proof is recursive! (xs++ ys) ++ zs≡ xs++ (ys ++ zs) x ∷ ((xs ++ ys) ++ zs) ≡ x ∷ (xs ++ (ys ++ zs)) ∎

  27. Agenda • Agda • What it is • Why it’s interesting • Some basic definitions and proofs • Demo • Emacs interaction • Typed holes • Short proofs

  28. Agda Strengths • Interactivity • Brevity: Unicode, mixfix • Proof terms • Powerful formalism, direct Curry-Howard • Active community and developers

  29. Agda Weaknesses • Large body of background knowledge • Poor error messages • Proof automation functionality is minimal • Counterpoint: mature Reflection API allows self service • Incomplete documentation • Slow

  30. “Agda-Curious”? • Programming Language Foundations in Agda • https://plfa.github.io/ • Port of Software Foundations (Coq) by Pierce, et al.

  31. Thank you! What questions do you have? An Introduction to Agda Curtis DunhamUniversity of Texas at AustinandArm Research

  32. Backup / Slide Graveyard

More Related