From 746f5bff0d171654ecd8c979c4562b63c1ff096b Mon Sep 17 00:00:00 2001 From: Leonardo de Moura Date: Wed, 10 Sep 2014 16:42:27 -0700 Subject: [PATCH] refactor(library/data/list/basic): cleanup Signed-off-by: Leonardo de Moura --- library/data/list/basic.lean | 162 +++++++++++++---------------------- 1 file changed, 61 insertions(+), 101 deletions(-) diff --git a/library/data/list/basic.lean b/library/data/list/basic.lean index a2e1b02eb..0de7819f6 100644 --- a/library/data/list/basic.lean +++ b/library/data/list/basic.lean @@ -23,9 +23,6 @@ nil {} : list T, cons : T → list T → list T namespace list - --- Type --- ---- infix `::` := cons section @@ -33,69 +30,50 @@ section variable {T : Type} theorem induction_on [protected] {P : list T → Prop} (l : list T) (Hnil : P nil) - (Hind : ∀ (x : T) (l : list T), P l → P (x :: l)) : P l := + (Hind : ∀ (x : T) (l : list T), P l → P (x::l)) : P l := rec Hnil Hind l theorem cases_on [protected] {P : list T → Prop} (l : list T) (Hnil : P nil) - (Hcons : ∀ (x : T) (l : list T), P (x :: l)) : P l := + (Hcons : ∀ (x : T) (l : list T), P (x::l)) : P l := induction_on l Hnil (take x l IH, Hcons x l) abbreviation rec_on [protected] {A : Type} {C : list A → Type} (l : list A) - (H1 : C nil) (H2 : Π (h : A) (t : list A), C t → C (h :: t)) : C l := + (H1 : C nil) (H2 : Π (h : A) (t : list A), C t → C (h::t)) : C l := rec H1 H2 l -notation `[` l:(foldr `,` (h t, h :: t) nil) `]` := l +notation `[` l:(foldr `,` (h t, h::t) nil) `]` := l -- Concat -- ------ definition append (s t : list T) : list T := -rec t (λx l u, x :: u) s +rec t (λx l u, x::u) s infixl `++` : 65 := append theorem nil_append {t : list T} : nil ++ t = t -theorem cons_append {x : T} {s t : list T} : (x :: s) ++ t = x :: (s ++ t) +theorem cons_append {x : T} {s t : list T} : x::s ++ t = x::(s ++ t) theorem append_nil {t : list T} : t ++ nil = t := -induction_on t rfl - (take (x : T) (l : list T) (H : append l nil = l), - H ▸ rfl) +induction_on t rfl (λx l H, H ▸ rfl) theorem append_assoc {s t u : list T} : s ++ t ++ u = s ++ (t ++ u) := -induction_on s - rfl - (take x l, assume H : (l ++ t) ++ u = l ++ (t ++ u), - calc - (x :: l) ++ t ++ u = x :: (l ++ t ++ u) : rfl - ... = x :: (l ++ (t ++ u)) : {H} - ... = (x :: l) ++ (t ++ u) : rfl) +induction_on s rfl (λx l H, H ▸ rfl) -- Length -- ------ -definition length : list T → ℕ := +definition length : list T → nat := rec 0 (λx l m, succ m) theorem length_nil : length (@nil T) = 0 -theorem length_cons {x : T} {t : list T} : length (x :: t) = succ (length t) +theorem length_cons {x : T} {t : list T} : length (x::t) = succ (length t) theorem length_append {s t : list T} : length (s ++ t) = length s + length t := -induction_on s - (calc - length (nil ++ t) = length t : rfl - ... = 0 + length t : {add_zero_left⁻¹} - ... = length nil + length t : rfl) - (take x s, - assume H : length (s ++ t) = length s + length t, - calc - length ((x :: s) ++ t ) = succ (length (s ++ t)) : rfl - ... = succ (length s + length t) : {H} - ... = succ (length s) + length t : {add_succ_left⁻¹} - ... = length (x :: s) + length t : rfl) +induction_on s (add_zero_left⁻¹) (λx s H, add_succ_left⁻¹ ▸ H ▸ rfl) -- add_rewrite length_nil length_cons @@ -103,11 +81,11 @@ induction_on s -- ------ definition concat (x : T) : list T → list T := -rec [x] (λy l l', y :: l') +rec [x] (λy l l', y::l') theorem concat_nil {x : T} : concat x nil = [x] -theorem concat_cons {x y : T} {l : list T} : concat x (y :: l) = y :: (concat x l) +theorem concat_cons {x y : T} {l : list T} : concat x (y::l) = y::(concat x l) theorem concat_eq_append {x : T} {l : list T} : concat x l = l ++ [x] @@ -121,42 +99,24 @@ rec nil (λx l r, r ++ [x]) theorem reverse_nil : reverse (@nil T) = nil -theorem reverse_cons {x : T} {l : list T} : reverse (x :: l) = concat x (reverse l) +theorem reverse_cons {x : T} {l : list T} : reverse (x::l) = concat x (reverse l) theorem reverse_singleton {x : T} : reverse [x] = [x] theorem reverse_append {s t : list T} : reverse (s ++ t) = (reverse t) ++ (reverse s) := -induction_on s - (append_nil⁻¹) - (take x s, assume IH : reverse (s ++ t) = (reverse t) ++ (reverse s), - calc - reverse ((x :: s) ++ t) = reverse (s ++ t) ++ [x] : rfl - ... = reverse t ++ reverse s ++ [x] : {IH} - ... = reverse t ++ (reverse s ++ [x]) : append_assoc - ... = reverse t ++ (reverse (x :: s)) : rfl) +induction_on s (append_nil⁻¹) + (λx s H, calc + reverse (x::s ++ t) = reverse t ++ reverse s ++ [x] : {H} + ... = reverse t ++ (reverse s ++ [x]) : append_assoc) theorem reverse_reverse {l : list T} : reverse (reverse l) = l := -induction_on l - rfl - (take x l', - assume H: reverse (reverse l') = l', - show reverse (reverse (x :: l')) = x :: l', from - calc - reverse (reverse (x :: l')) = reverse (reverse l' ++ [x]) : rfl - ... = reverse [x] ++ reverse (reverse l') : reverse_append - ... = [x] ++ l' : {H} - ... = x :: l' : rfl) +induction_on l rfl (λx l' H, H ▸ reverse_append) theorem concat_eq_reverse_cons {x : T} {l : list T} : concat x l = reverse (x :: reverse l) := -induction_on l - rfl - (take y l', - assume H : concat x l' = reverse (x :: reverse l'), - calc - concat x (y :: l') = (y :: l') ++ [x] : concat_eq_append - ... = reverse (reverse (y :: l')) ++ [x] : {reverse_reverse⁻¹} - ... = reverse (x :: (reverse (y :: l'))) : rfl) - +induction_on l rfl + (λy l' H, calc + concat x (y::l') = (y::l') ++ [x] : concat_eq_append + ... = reverse (reverse (y::l')) ++ [x] : {reverse_reverse⁻¹}) -- Head and tail -- ------------- @@ -166,28 +126,28 @@ rec x (λx l h, x) theorem head_nil {x : T} : head x nil = x -theorem head_cons {x x' : T} {t : list T} : head x' (x :: t) = x +theorem head_cons {x x' : T} {t : list T} : head x' (x::t) = x theorem head_concat {s t : list T} {x : T} : s ≠ nil → (head x (s ++ t) = head x s) := cases_on s (take H : nil ≠ nil, absurd rfl H) - (take x s, take H : x :: s ≠ nil, + (take x s, take H : x::s ≠ nil, calc - head x ((x :: s) ++ t) = head x (x :: (s ++ t)) : {cons_append} - ... = x : {head_cons} - ... = head x (x :: s) : {head_cons⁻¹}) + head x (x::s ++ t) = head x (x::(s ++ t)) : {cons_append} + ... = x : {head_cons} + ... = head x (x::s) : {head_cons⁻¹}) definition tail : list T → list T := rec nil (λx l b, l) theorem tail_nil : tail (@nil T) = nil -theorem tail_cons {x : T} {l : list T} : tail (x :: l) = l +theorem tail_cons {x : T} {l : list T} : tail (x::l) = l -theorem cons_head_tail {x : T} {l : list T} : l ≠ nil → (head x l) :: (tail l) = l := +theorem cons_head_tail {x : T} {l : list T} : l ≠ nil → (head x l)::(tail l) = l := cases_on l (assume H : nil ≠ nil, absurd rfl H) - (take x l, assume H : x :: l ≠ nil, rfl) + (take x l, assume H : x::l ≠ nil, rfl) -- List membership -- --------------- @@ -200,14 +160,14 @@ infix `∈` := mem theorem mem_nil {x : T} : x ∈ nil ↔ false := iff.rfl -theorem mem_cons {x y : T} {l : list T} : mem x (y :: l) ↔ (x = y ∨ mem x l) := +theorem mem_cons {x y : T} {l : list T} : x ∈ y::l ↔ (x = y ∨ x ∈ l) := iff.rfl theorem mem_concat_imp_or {x : T} {s t : list T} : x ∈ s ++ t → x ∈ s ∨ x ∈ t := induction_on s or.inr (take y s, assume IH : x ∈ s ++ t → x ∈ s ∨ x ∈ t, - assume H1 : x ∈ (y :: s) ++ t, + assume H1 : x ∈ y::s ++ t, have H2 : x = y ∨ x ∈ s ++ t, from H1, have H3 : x = y ∨ x ∈ s ∨ x ∈ t, from or.imp_or_right H2 IH, iff.elim_right or.assoc H3) @@ -217,7 +177,7 @@ induction_on s (take H, or.elim H false_elim (assume H, H)) (take y s, assume IH : x ∈ s ∨ x ∈ t → x ∈ s ++ t, - assume H : x ∈ y :: s ∨ x ∈ t, + assume H : x ∈ y::s ∨ x ∈ t, or.elim H (assume H1, or.elim H1 @@ -228,44 +188,44 @@ induction_on s theorem mem_concat {x : T} {s t : list T} : x ∈ s ++ t ↔ x ∈ s ∨ x ∈ t := iff.intro mem_concat_imp_or mem_or_imp_concat -theorem mem_split {x : T} {l : list T} : x ∈ l → ∃s t : list T, l = s ++ (x :: t) := +theorem mem_split {x : T} {l : list T} : x ∈ l → ∃s t : list T, l = s ++ (x::t) := induction_on l (take H : x ∈ nil, false_elim (iff.elim_left mem_nil H)) (take y l, - assume IH : x ∈ l → ∃s t : list T, l = s ++ (x :: t), - assume H : x ∈ y :: l, + assume IH : x ∈ l → ∃s t : list T, l = s ++ (x::t), + assume H : x ∈ y::l, or.elim H (assume H1 : x = y, exists_intro nil (exists_intro l (H1 ▸ rfl))) (assume H1 : x ∈ l, - obtain s (H2 : ∃t : list T, l = s ++ (x :: t)), from IH H1, - obtain t (H3 : l = s ++ (x :: t)), from H2, - have H4 : y :: l = (y :: s) ++ (x :: t), + obtain s (H2 : ∃t : list T, l = s ++ (x::t)), from IH H1, + obtain t (H3 : l = s ++ (x::t)), from H2, + have H4 : y :: l = (y::s) ++ (x::t), from H3 ▸ rfl, exists_intro _ (exists_intro _ H4))) -theorem mem_is_decidable [instance] {H : decidable_eq T} {x : T} {l : list T} : decidable (mem x l) := +theorem mem_is_decidable [instance] {H : decidable_eq T} {x : T} {l : list T} : decidable (x ∈ l) := rec_on l (decidable.inr (iff.false_elim mem_nil)) - (λ (h : T) (l : list T) (iH : decidable (mem x l)), - show decidable (mem x (h :: l)), from + (λ (h : T) (l : list T) (iH : decidable (x ∈ l)), + show decidable (x ∈ h::l), from decidable.rec_on iH - (assume Hp : mem x l, + (assume Hp : x ∈ l, decidable.rec_on (H x h) (assume Heq : x = h, decidable.inl (or.inl Heq)) (assume Hne : x ≠ h, decidable.inl (or.inr Hp))) - (assume Hn : ¬mem x l, + (assume Hn : ¬x ∈ l, decidable.rec_on (H x h) (assume Heq : x = h, decidable.inl (or.inl Heq)) (assume Hne : x ≠ h, - have H1 : ¬(x = h ∨ mem x l), from - assume H2 : x = h ∨ mem x l, or.elim H2 + have H1 : ¬(x = h ∨ x ∈ l), from + assume H2 : x = h ∨ x ∈ l, or.elim H2 (assume Heq, absurd Heq Hne) (assume Hp, absurd Hp Hn), - have H2 : ¬mem x (h :: l), from + have H2 : ¬x ∈ h::l, from iff.elim_right (iff.flip_sign mem_cons) H1, decidable.inr H2))) @@ -278,31 +238,31 @@ rec 0 (λy l b, if x = y then 0 else succ b) theorem find_nil {H : decidable_eq T} {f : T} : find f nil = 0 theorem find_cons {H : decidable_eq T} {x y : T} {l : list T} : - find x (y :: l) = if x = y then 0 else succ (find x l) + find x (y::l) = if x = y then 0 else succ (find x l) theorem not_mem_find {H : decidable_eq T} {l : list T} {x : T} : - ¬mem x l → find x l = length l := + ¬x ∈ l → find x l = length l := rec_on l - (assume P₁ : ¬mem x nil, rfl) + (assume P₁ : ¬x ∈ nil, rfl) (take y l, - assume iH : ¬mem x l → find x l = length l, - assume P₁ : ¬mem x (y :: l), - have P₂ : ¬(x = y ∨ mem x l), from iff.elim_right (iff.flip_sign mem_cons) P₁, - have P₃ : ¬x = y ∧ ¬mem x l, from (iff.elim_left not_or P₂), + assume iH : ¬x ∈ l → find x l = length l, + assume P₁ : ¬x ∈ y::l, + have P₂ : ¬(x = y ∨ x ∈ l), from iff.elim_right (iff.flip_sign mem_cons) P₁, + have P₃ : ¬x = y ∧ ¬x ∈ l, from (iff.elim_left not_or P₂), calc - find x (y :: l) = if x = y then 0 else succ (find x l) : find_cons - ... = succ (find x l) : if_neg (and.elim_left P₃) - ... = succ (length l) : {iH (and.elim_right P₃)} - ... = length (y :: l) : length_cons⁻¹) + find x (y::l) = if x = y then 0 else succ (find x l) : find_cons + ... = succ (find x l) : if_neg (and.elim_left P₃) + ... = succ (length l) : {iH (and.elim_right P₃)} + ... = length (y::l) : length_cons⁻¹) -- nth element -- ----------- -definition nth (x : T) (l : list T) (n : ℕ) : T := +definition nth (x : T) (l : list T) (n : nat) : T := nat.rec (λl, head x l) (λm f l, f (tail l)) n l theorem nth_zero {x : T} {l : list T} : nth x l 0 = head x l -theorem nth_succ {x : T} {l : list T} {n : ℕ} : nth x l (succ n) = nth x (tail l) n +theorem nth_succ {x : T} {l : list T} {n : nat} : nth x l (succ n) = nth x (tail l) n end end list