156 lines
4.0 KiB
Plaintext
156 lines
4.0 KiB
Plaintext
|
/-
|
|||
|
Chapter 8
|
|||
|
|
|||
|
Induction and Recursion
|
|||
|
-/
|
|||
|
|
|||
|
-- ========================================
|
|||
|
-- Exercise 1
|
|||
|
--
|
|||
|
-- Open a namespace `Hidden` to avoid naming conflicts, and use the equation
|
|||
|
-- compiler to define addition, multiplication, and exponentiation on the
|
|||
|
-- natural numbers. Then use the equation compiler to derive some of their basic
|
|||
|
-- properties.
|
|||
|
-- ========================================
|
|||
|
|
|||
|
namespace ex1
|
|||
|
|
|||
|
def add : Nat → Nat → Nat
|
|||
|
| m, Nat.zero => m
|
|||
|
| m, Nat.succ n => Nat.succ (add m n)
|
|||
|
|
|||
|
def mul : Nat → Nat → Nat
|
|||
|
| _, Nat.zero => 0
|
|||
|
| m, Nat.succ n => add m (mul m n)
|
|||
|
|
|||
|
def exp : Nat → Nat → Nat
|
|||
|
| _, Nat.zero => 1
|
|||
|
| m, Nat.succ n => mul m (exp m n)
|
|||
|
|
|||
|
end ex1
|
|||
|
|
|||
|
-- ========================================
|
|||
|
-- Exercise 2
|
|||
|
--
|
|||
|
-- Similarly, use the equation compiler to define some basic operations on lists
|
|||
|
-- (like the reverse function) and prove theorems about lists by induction (such
|
|||
|
-- as the fact that `reverse (reverse xs) = xs` for any list `xs`).
|
|||
|
-- ========================================
|
|||
|
|
|||
|
namespace ex2
|
|||
|
|
|||
|
variable {α : Type _}
|
|||
|
|
|||
|
def reverse : List α → List α
|
|||
|
| [] => []
|
|||
|
| (head :: tail) => reverse tail ++ [head]
|
|||
|
|
|||
|
-- Proof of `reverse (reverse xs) = xs` shown in previous exercise.
|
|||
|
|
|||
|
end ex2
|
|||
|
|
|||
|
-- ========================================
|
|||
|
-- Exercise 3
|
|||
|
--
|
|||
|
-- Define your own function to carry out course-of-value recursion on the
|
|||
|
-- natural numbers. Similarly, see if you can figure out how to define
|
|||
|
-- `WellFounded.fix` on your own.
|
|||
|
-- ========================================
|
|||
|
|
|||
|
namespace ex3
|
|||
|
|
|||
|
def below {motive : Nat → Type} : Nat → Type
|
|||
|
| Nat.zero => PUnit
|
|||
|
| Nat.succ n => PProd (PProd (motive n) (@below motive n)) (PUnit : Type)
|
|||
|
|
|||
|
-- TODO: Sort out how to write `brecOn` and `WellFounded.fix`.
|
|||
|
|
|||
|
end ex3
|
|||
|
|
|||
|
-- ========================================
|
|||
|
-- Exercise 4
|
|||
|
--
|
|||
|
-- Following the examples in Section Dependent Pattern Matching, define a
|
|||
|
-- function that will append two vectors. This is tricky; you will have to
|
|||
|
-- define an auxiliary function.
|
|||
|
-- ========================================
|
|||
|
|
|||
|
namespace ex4
|
|||
|
|
|||
|
inductive Vector (α : Type u) : Nat → Type u
|
|||
|
| nil : Vector α 0
|
|||
|
| cons : α → {n : Nat} → Vector α n → Vector α (n + 1)
|
|||
|
|
|||
|
namespace Vector
|
|||
|
|
|||
|
-- TODO: Sort out how to write `append`.
|
|||
|
|
|||
|
end Vector
|
|||
|
|
|||
|
end ex4
|
|||
|
|
|||
|
-- ========================================
|
|||
|
-- Exercise 5
|
|||
|
--
|
|||
|
-- Consider the following type of arithmetic expressions. The idea is that
|
|||
|
-- `var n` is a variable, `vₙ`, and `const n` is the constant whose value is
|
|||
|
-- `n`.
|
|||
|
-- ========================================
|
|||
|
|
|||
|
namespace ex5
|
|||
|
|
|||
|
inductive Expr where
|
|||
|
| const : Nat → Expr
|
|||
|
| var : Nat → Expr
|
|||
|
| plus : Expr → Expr → Expr
|
|||
|
| times : Expr → Expr → Expr
|
|||
|
deriving Repr
|
|||
|
|
|||
|
open Expr
|
|||
|
|
|||
|
def sampleExpr : Expr :=
|
|||
|
plus (times (var 0) (const 7)) (times (const 2) (var 1))
|
|||
|
|
|||
|
-- Here `sampleExpr` represents `(v₀ * 7) + (2 * v₁)`. Write a function that
|
|||
|
-- evaluates such an expression, evaluating each `var n` to `v n`.
|
|||
|
|
|||
|
def eval (v : Nat → Nat) : Expr → Nat
|
|||
|
| const n => sorry
|
|||
|
| var n => v n
|
|||
|
| plus e₁ e₂ => sorry
|
|||
|
| times e₁ e₂ => sorry
|
|||
|
|
|||
|
def sampleVal : Nat → Nat
|
|||
|
| 0 => 5
|
|||
|
| 1 => 6
|
|||
|
| _ => 0
|
|||
|
|
|||
|
-- Try it out. You should get 47 here.
|
|||
|
-- #eval eval sampleVal sampleExpr
|
|||
|
|
|||
|
-- ----------------------------------------
|
|||
|
-- Implement "constant fusion," a procedure that simplifies subterms like
|
|||
|
-- `5 + 7` to `12`. Using the auxiliary function `simpConst`, define a function
|
|||
|
-- "fuse": to simplify a plus or a times, first simplify the arguments
|
|||
|
-- recursively, and then apply `simpConst` to try to simplify the result.
|
|||
|
-- ----------------------------------------
|
|||
|
|
|||
|
def simpConst : Expr → Expr
|
|||
|
| plus (const n₁) (const n₂) => const (n₁ + n₂)
|
|||
|
| times (const n₁) (const n₂) => const (n₁ * n₂)
|
|||
|
| e => e
|
|||
|
|
|||
|
def fuse : Expr → Expr := sorry
|
|||
|
|
|||
|
theorem simpConst_eq (v : Nat → Nat)
|
|||
|
: ∀ e : Expr, eval v (simpConst e) = eval v e :=
|
|||
|
sorry
|
|||
|
|
|||
|
theorem fuse_eq (v : Nat → Nat)
|
|||
|
: ∀ e : Expr, eval v (fuse e) = eval v e :=
|
|||
|
sorry
|
|||
|
|
|||
|
-- The last two theorems show that the definitions preserve the value.
|
|||
|
|
|||
|
end ex5
|