refactor: Start filling in sorries
This commit is contained in:
jstoobysmith
parent
dceaab7117
commit
3123e831d8
6 changed files with 467 additions and 28 deletions
|
|
@ -17,6 +17,116 @@ open Fin
|
|||
open HepLean
|
||||
variable {n : Nat}
|
||||
|
||||
def orderedInsertPos {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I) (r0 : I) :
|
||||
Fin (List.orderedInsert le1 r0 r).length :=
|
||||
⟨(List.takeWhile (fun b => decide ¬ le1 r0 b) r).length, by
|
||||
rw [List.orderedInsert_length]
|
||||
have h1 : (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ r.length :=
|
||||
List.Sublist.length_le (List.takeWhile_sublist fun b => decide ¬le1 r0 b)
|
||||
omega⟩
|
||||
|
||||
lemma orderedInsertPos_lt_length {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
|
||||
(r0 : I) : orderedInsertPos le1 r r0 < (r0 :: r).length := by
|
||||
simp only [orderedInsertPos, List.length_cons]
|
||||
have h1 : (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ r.length :=
|
||||
List.Sublist.length_le (List.takeWhile_sublist fun b => decide ¬le1 r0 b)
|
||||
omega
|
||||
|
||||
@[simp]
|
||||
lemma orderedInsert_get_orderedInsertPos {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
|
||||
(r : List I) (r0 : I) :
|
||||
(List.orderedInsert le1 r0 r)[(orderedInsertPos le1 r r0).val] = r0 := by
|
||||
simp [orderedInsertPos, List.orderedInsert_eq_take_drop]
|
||||
rw [List.getElem_append]
|
||||
simp
|
||||
|
||||
|
||||
@[simp]
|
||||
lemma orderedInsert_get_lt {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
|
||||
(r : List I) (r0 : I) (i : Fin (List.orderedInsert le1 r0 r).length)
|
||||
(hi : i.val < orderedInsertPos le1 r r0) :
|
||||
(List.orderedInsert le1 r0 r)[i] = r.get ⟨i, by
|
||||
simp only [orderedInsertPos] at hi
|
||||
have h1 : (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ r.length :=
|
||||
List.Sublist.length_le (List.takeWhile_sublist fun b => decide ¬le1 r0 b)
|
||||
omega⟩ := by
|
||||
simp [orderedInsertPos] at hi
|
||||
simp [List.orderedInsert_eq_take_drop]
|
||||
rw [List.getElem_append]
|
||||
simp [hi]
|
||||
rw [List.IsPrefix.getElem]
|
||||
exact List.takeWhile_prefix fun b => !decide (le1 r0 b)
|
||||
|
||||
def orderedInsertEquiv {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I) (r0 : I) :
|
||||
Fin (r0 :: r).length ≃ Fin (List.orderedInsert le1 r0 r).length := by
|
||||
let e2 : Fin (List.orderedInsert le1 r0 r).length ≃ Fin (r0 :: r).length :=
|
||||
(Fin.castOrderIso (List.orderedInsert_length le1 r r0)).toEquiv
|
||||
let e3 : Fin (r0 :: r).length ≃ Fin 1 ⊕ Fin (r).length := finExtractOne 0
|
||||
let e4 : Fin (r0 :: r).length ≃ Fin 1 ⊕ Fin (r).length := finExtractOne ⟨orderedInsertPos le1 r r0, orderedInsertPos_lt_length le1 r r0⟩
|
||||
exact e3.trans (e4.symm.trans e2.symm)
|
||||
|
||||
@[simp]
|
||||
lemma orderedInsertEquiv_zero {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
|
||||
(r0 : I) : orderedInsertEquiv le1 r r0 ⟨0, by simp⟩ = orderedInsertPos le1 r r0 := by
|
||||
simp [orderedInsertEquiv]
|
||||
|
||||
@[simp]
|
||||
lemma orderedInsertEquiv_succ {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
|
||||
(r0 : I) (n : ℕ) (hn : Nat.succ n < (r0 :: r).length) :
|
||||
orderedInsertEquiv le1 r r0 ⟨Nat.succ n, hn⟩ = Fin.cast (List.orderedInsert_length le1 r r0).symm
|
||||
((Fin.succAbove ⟨(orderedInsertPos le1 r r0), orderedInsertPos_lt_length le1 r r0⟩) ⟨n, Nat.succ_lt_succ_iff.mp hn⟩) := by
|
||||
simp [orderedInsertEquiv]
|
||||
match r with
|
||||
| [] =>
|
||||
simp
|
||||
| r1 :: r =>
|
||||
erw [finExtractOne_apply_neq]
|
||||
simp [orderedInsertPos]
|
||||
rfl
|
||||
exact ne_of_beq_false rfl
|
||||
|
||||
|
||||
lemma get_eq_orderedInsertEquiv {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
|
||||
(r0 : I) :
|
||||
(r0 :: r).get = (List.orderedInsert le1 r0 r).get ∘ (orderedInsertEquiv le1 r r0) := by
|
||||
funext x
|
||||
match x with
|
||||
| ⟨0, h⟩ =>
|
||||
simp
|
||||
erw [orderedInsertEquiv_zero]
|
||||
simp
|
||||
| ⟨Nat.succ n, h⟩ =>
|
||||
simp
|
||||
erw [orderedInsertEquiv_succ]
|
||||
simp [Fin.succAbove]
|
||||
by_cases hn : n < ↑(orderedInsertPos le1 r r0)
|
||||
· simp [hn]
|
||||
erw [orderedInsert_get_lt le1 r r0 ⟨n, by omega⟩ ]
|
||||
rfl
|
||||
simpa using hn
|
||||
· simp [hn]
|
||||
simp [List.orderedInsert_eq_take_drop]
|
||||
rw [List.getElem_append]
|
||||
have hn' : ¬ n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length := by
|
||||
simp [orderedInsertPos] at hn
|
||||
omega
|
||||
simp [hn']
|
||||
have hnn : n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
|
||||
(n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length) + 1 := by
|
||||
simp [orderedInsertPos] at hn
|
||||
omega
|
||||
simp [hnn]
|
||||
conv_rhs =>
|
||||
rw [List.IsSuffix.getElem (List.dropWhile_suffix fun b => !decide (le1 r0 b))]
|
||||
congr
|
||||
have hr : r.length = (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + (List.dropWhile (fun b => !decide (le1 r0 b)) r).length := by
|
||||
rw [← List.length_append]
|
||||
congr
|
||||
exact Eq.symm (List.takeWhile_append_dropWhile (fun b => !decide (le1 r0 b)) r)
|
||||
simp [hr]
|
||||
omega
|
||||
|
||||
|
||||
/-- The equivalence between `Fin (a :: l).length` and `Fin (List.orderedInsert r a l).length`
|
||||
mapping `0` in the former to the location of `a` in the latter. -/
|
||||
def insertEquiv {α : Type} (r : α → α → Prop) [DecidableRel r] (a : α) : (l : List α) →
|
||||
|
|
@ -172,24 +282,107 @@ lemma eraseIdx_cons_length {I : Type} (a : I) (l : List I) (i : Fin (a :: l).len
|
|||
|
||||
|
||||
lemma eraseIdx_get {I : Type} (l : List I) (i : Fin l.length) :
|
||||
(List.eraseIdx l i).get = l.get ∘ (Fin.cast (eraseIdx_length l i)) ∘ i.succAbove := by
|
||||
(List.eraseIdx l i).get = l.get ∘ (Fin.cast (eraseIdx_length l i)) ∘ (Fin.cast (eraseIdx_length l i).symm i).succAbove := by
|
||||
ext x
|
||||
simp only [Function.comp_apply, List.get_eq_getElem, List.eraseIdx, List.getElem_eraseIdx]
|
||||
simp [Fin.succAbove]
|
||||
by_cases hi: x.1 < i.val
|
||||
· have h0 : x.castSucc < ↑↑i := by
|
||||
simp [Fin.lt_def]
|
||||
rw [Nat.mod_eq_of_lt]
|
||||
exact hi
|
||||
rw [eraseIdx_length]
|
||||
exact i.prop
|
||||
simp [h0, hi]
|
||||
· have h0 : ¬ x.castSucc < ↑↑i := by
|
||||
simp [Fin.lt_def]
|
||||
rw [Nat.mod_eq_of_lt]
|
||||
exact Nat.le_of_not_lt hi
|
||||
rw [eraseIdx_length]
|
||||
exact i.prop
|
||||
simp [h0, hi]
|
||||
by_cases hi: x.castSucc < Fin.cast (by exact Eq.symm (eraseIdx_length l i)) i
|
||||
· simp [ hi]
|
||||
intro h
|
||||
rw [Fin.lt_def] at hi
|
||||
simp_all
|
||||
omega
|
||||
· simp [ hi]
|
||||
rw [Fin.lt_def] at hi
|
||||
simp at hi
|
||||
have hn : ¬ x.val < i.val := by omega
|
||||
simp [hn]
|
||||
|
||||
|
||||
lemma eraseIdx_insertionSort_length {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
|
||||
(n : Fin r.length ) :
|
||||
((List.insertionSort le1 r).eraseIdx ↑((HepLean.List.insertionSortEquiv le1 r) n)).length
|
||||
= (List.insertionSort le1 (r.eraseIdx n)).length := by
|
||||
rw [List.length_eraseIdx]
|
||||
have hn := ((insertionSortEquiv le1 r) n).prop
|
||||
simp [List.length_insertionSort] at hn
|
||||
simp [hn]
|
||||
rw [List.length_eraseIdx]
|
||||
simp
|
||||
|
||||
lemma eraseIdx_insertionSort_get {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
|
||||
(n : Fin r.length ) :
|
||||
((List.insertionSort le1 r).eraseIdx ↑((HepLean.List.insertionSortEquiv le1 r) n)).get
|
||||
= (List.insertionSort le1 (r.eraseIdx n)).get ∘ Fin.cast (eraseIdx_insertionSort_length le1 r n) := by
|
||||
rw [eraseIdx_get, ← insertionSortEquiv_get, ← insertionSortEquiv_get,
|
||||
eraseIdx_get]
|
||||
|
||||
@[simp]
|
||||
lemma eraseIdx_orderedInsert_zero {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
|
||||
(r0 : I) :
|
||||
(List.orderedInsert le1 r0 r).eraseIdx ↑((insertEquiv le1 r0 r) ⟨0, by simp⟩) = r := by
|
||||
induction r with
|
||||
| nil => simp
|
||||
| cons r1 r ih =>
|
||||
by_cases hr0 : le1 r0 r1
|
||||
· simp [hr0, insertEquiv]
|
||||
· simp [hr0, insertEquiv, equivCons]
|
||||
simpa using ih
|
||||
|
||||
@[simp]
|
||||
lemma eraseIdx_orderedInsert_succ_succ {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
|
||||
(r0 : I) (n : ℕ) (hn : Nat.succ (Nat.succ n) < (r0 :: r).length) :
|
||||
(List.orderedInsert le1 r0 r).eraseIdx ↑((insertEquiv le1 r0 r) ⟨Nat.succ (Nat.succ n), hn⟩) =
|
||||
List.orderedInsert le1 r0 (r.eraseIdx (Nat.succ n)) := by
|
||||
induction r with
|
||||
| nil => simp at hn
|
||||
| cons r1 r ih =>
|
||||
by_cases hr0 : le1 r0 r1
|
||||
· simp [hr0, insertEquiv]
|
||||
· simp [hr0, insertEquiv]
|
||||
rw [Equiv.swap_apply_of_ne_of_ne]
|
||||
simp
|
||||
have h1 (n : ℕ) (hn : n + 1 < (r0 :: r).length) : (List.orderedInsert le1 r0 r).eraseIdx ↑((insertEquiv le1 r0 r) ⟨n + 1, hn⟩) =
|
||||
List.orderedInsert le1 r0 (r.eraseIdx n) := by
|
||||
match n with
|
||||
| 0 => simp
|
||||
| Nat.succ n =>
|
||||
exact ih ?_
|
||||
sorry
|
||||
exact h1 n (Nat.succ_lt_succ_iff.mp hn)
|
||||
simp
|
||||
rw [Fin.ext_iff]
|
||||
simp
|
||||
simp
|
||||
rw [Fin.ext_iff]
|
||||
simp
|
||||
|
||||
lemma eraseIdx_insertionSort_zero {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
|
||||
(h0 : 0 < r.length) :
|
||||
((List.insertionSort le1 r).eraseIdx ↑((HepLean.List.insertionSortEquiv le1 r) ⟨0, h0⟩))
|
||||
= (List.insertionSort le1 (r.eraseIdx 0)) := by
|
||||
induction r with
|
||||
| nil => simp
|
||||
| cons r0 r ih =>
|
||||
simp [insertionSortEquiv]
|
||||
erw [eraseIdx_orderedInsert_zero]
|
||||
|
||||
lemma eraseIdx_insertionSort_succ {I : Type} (le1 : I → I → Prop) [DecidableRel le1] :
|
||||
(n : ℕ) → (r : List I) → (hn : n < r.length) →
|
||||
((List.insertionSort le1 r).eraseIdx ↑((HepLean.List.insertionSortEquiv le1 r) ⟨n, hn⟩))
|
||||
= (List.insertionSort le1 (r.eraseIdx n))
|
||||
| 0, _, _ => by exact eraseIdx_insertionSort_zero le1 _ _
|
||||
| Nat.succ n, [], hn => by
|
||||
simp [insertionSortEquiv]
|
||||
| Nat.succ 0, (r0 :: r), hn => by
|
||||
simp [insertionSortEquiv]
|
||||
|
||||
|
||||
|
||||
| Nat.succ (Nat.succ n), (r0 :: r), hn => by
|
||||
simp [insertionSortEquiv]
|
||||
rw [eraseIdx_orderedInsert_succ_succ]
|
||||
exact eraseIdx_insertionSort_succ n r (Nat.lt_of_succ_lt hn)
|
||||
|
||||
|
||||
end HepLean.List
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue