refactor(library/data/list/basic): cleanup
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
This commit is contained in:
Leonardo de Moura
parent
1e5ba9bd75
commit
746f5bff0d
1 changed files with 61 additions and 101 deletions
|
|
@ -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}
|
||||
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) : {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
|
||||
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⁻¹)
|
||||
... = 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
|
||||
|
|
|
|||
Loading…
Reference in a new issue