Physlib.Mathematics.List.InsertionSort

Physlib
Mathematics
List
InsertionSort

Imports

/-
Copyright (c) 2024 Joseph Tooby-Smith. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Joseph Tooby-Smith
-/
module
public import Physlib.Mathematics.List
import all Physlib.Mathematics.List

List lemmas

@[expose] public section

lemma insertionSortMin_lt_length_succ {α : Type} (r : α → α → Prop) [DecidableRel r]
    (i : α) (l : List α) :
    insertionSortMinPos r i l < (insertionSortDropMinPos r i l).length.succ := byα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ ↑(insertionSortMinPos r i l) < (insertionSortDropMinPos r i l).length.succ
  simp [insertionSortMinPos, insertionSortDropMinPos, eraseIdx_length']All goals completed! 🐙

Given a list i :: l the left-most minimal position a of i :: l wrt r as an element of Fin (insertionSortDropMinPos r i l).length.succ.

def insertionSortMinPosFin {α : Type} (r : α → α → Prop) [DecidableRel r] (i : α) (l : List α) :
    Fin (insertionSortDropMinPos r i l).length.succ :=
  ⟨insertionSortMinPos r i l, insertionSortMin_lt_length_succ r i l⟩

              

lemma insertionSortMin_lt_mem_insertionSortDropMinPos {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (a : α) (l : List α)
    (i : Fin (insertionSortDropMinPos r a l).length) :
    r (insertionSortMin r a l) ((insertionSortDropMinPos r a l)[i]) := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl:List αi:Fin (insertionSortDropMinPos r a l).length⊢ r (insertionSortMin r a l) (insertionSortDropMinPos r a l)[i]
  have hl1 := List.pairwise_insertionSort r (a :: l)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthhl1:List.Pairwise r (List.insertionSort r (a :: l))⊢ r (insertionSortMin r a l) (insertionSortDropMinPos r a l)[i]
  rw [insertionSort_eq_insertionSortMin_cons r a l,α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthhl1:List.Pairwise r (insertionSortMin r a l :: List.insertionSort r (insertionSortDropMinPos r a l))⊢ r (insertionSortMin r a l) (insertionSortDropMinPos r a l)[i]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthhl1:(∀ a' ∈ List.insertionSort r (insertionSortDropMinPos r a l), r (insertionSortMin r a l) a') ∧
  List.Pairwise r (List.insertionSort r (insertionSortDropMinPos r a l))⊢ r (insertionSortMin r a l) (insertionSortDropMinPos r a l)[i] List.pairwise_consα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthhl1:(∀ a' ∈ List.insertionSort r (insertionSortDropMinPos r a l), r (insertionSortMin r a l) a') ∧
  List.Pairwise r (List.insertionSort r (insertionSortDropMinPos r a l))⊢ r (insertionSortMin r a l) (insertionSortDropMinPos r a l)[i]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthhl1:(∀ a' ∈ List.insertionSort r (insertionSortDropMinPos r a l), r (insertionSortMin r a l) a') ∧
  List.Pairwise r (List.insertionSort r (insertionSortDropMinPos r a l))⊢ r (insertionSortMin r a l) (insertionSortDropMinPos r a l)[i]] at hl1α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthhl1:(∀ a' ∈ List.insertionSort r (insertionSortDropMinPos r a l), r (insertionSortMin r a l) a') ∧
  List.Pairwise r (List.insertionSort r (insertionSortDropMinPos r a l))⊢ r (insertionSortMin r a l) (insertionSortDropMinPos r a l)[i]
  exact hl1.1 _ (byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthhl1:(∀ a' ∈ List.insertionSort r (insertionSortDropMinPos r a l), r (insertionSortMin r a l) a') ∧
  List.Pairwise r (List.insertionSort r (insertionSortDropMinPos r a l))⊢ (insertionSortDropMinPos r a l)[i] ∈ List.insertionSort r (insertionSortDropMinPos r a l) simpAll goals completed! 🐙)

lemma insertionSortMinPos_insertionSortEquiv {α : Type} (r : α → α → Prop) [DecidableRel r]
    (a : α) (l : List α) :
    insertionSortEquiv r (a ::l) (insertionSortMinPos r a l) =
    ⟨0, byn:ℕα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ 0 < (List.insertionSort r (a :: l)).length simp [List.orderedInsert_length]All goals completed! 🐙⟩ := byα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (insertionSortEquiv r (a :: l)) (insertionSortMinPos r a l) = ⟨0, ⋯⟩
  rw [insertionSortMinPosα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (insertionSortEquiv r (a :: l)) ((insertionSortEquiv r (a :: l)).symm ⟨0, ⋯⟩) = ⟨0, ⋯⟩α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (insertionSortEquiv r (a :: l)) ((insertionSortEquiv r (a :: l)).symm ⟨0, ⋯⟩) = ⟨0, ⋯⟩]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (insertionSortEquiv r (a :: l)) ((insertionSortEquiv r (a :: l)).symm ⟨0, ⋯⟩) = ⟨0, ⋯⟩
  exact Equiv.apply_symm_apply (insertionSortEquiv r (a :: l)) ⟨0, _⟩All goals completed! 🐙lemma insertionSortEquiv_gt_zero_of_ne_insertionSortMinPos {α : Type} (r : α → α → Prop)
    [DecidableRel r] (a : α) (l : List α) (k : Fin (a :: l).length)
    (hk : k ≠ insertionSortMinPos r a l) :
    ⟨0, byn:ℕα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αk:Fin (a :: l).lengthhk:k ≠ insertionSortMinPos r a l⊢ 0 < (List.insertionSort r (a :: l)).length simp [List.orderedInsert_length]All goals completed! 🐙⟩ < insertionSortEquiv r (a :: l) k := byα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αk:Fin (a :: l).lengthhk:k ≠ insertionSortMinPos r a l⊢ ⟨0, ⋯⟩ < (insertionSortEquiv r (a :: l)) k
  by_contra hnα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αk:Fin (a :: l).lengthhk:k ≠ insertionSortMinPos r a lhn:¬⟨0, ⋯⟩ < (insertionSortEquiv r (a :: l)) k⊢ False
  simp only [List.length_cons, not_lt] at hnα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αk:Fin (a :: l).lengthhk:k ≠ insertionSortMinPos r a lhn:(insertionSortEquiv r (a :: l)) k ≤ ⟨0, ⋯⟩⊢ False
  refine hk ((Equiv.apply_eq_iff_eq_symm_apply (insertionSortEquiv r (a :: l))).mp ?_)α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αk:Fin (a :: l).lengthhk:k ≠ insertionSortMinPos r a lhn:(insertionSortEquiv r (a :: l)) k ≤ ⟨0, ⋯⟩⊢ (insertionSortEquiv r (a :: l)) k = ⟨0, ⋯⟩
  simp_all only [List.length_cons, ne_eq, Fin.le_def, nonpos_iff_eq_zero]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αk:Fin (a :: l).lengthhk:¬k = insertionSortMinPos r a lhn:↑((insertionSortEquiv r (a :: l)) k) = 0⊢ (insertionSortEquiv r (a :: l)) k = ⟨0, ⋯⟩
  exact Fin.ext hnAll goals completed! 🐙

lemma insertionSortMin_lt_mem_insertionSortDropMinPos_of_lt {α : Type} (r : α → α → Prop)
    [DecidableRel r] (a : α) (l : List α)
    (i : Fin (insertionSortDropMinPos r a l).length)
    (h : (insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l) :
    ¬ r ((insertionSortDropMinPos r a l)[i]) (insertionSortMin r a l) := byα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ ¬r (insertionSortDropMinPos r a l)[i] (insertionSortMin r a l)
  simp only [Fin.getElem_fin, insertionSortMin, List.get_eq_getElem, List.length_cons]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ ¬r (insertionSortDropMinPos r a l)[↑i] (a :: l)[↑(insertionSortMinPos r a l)]
  have h1 : (insertionSortDropMinPos r a l)[(i : ℕ)] =
    (a :: l).get (finCongr (eraseIdx_length_succ (a :: l) (insertionSortMinPos r a l))
    ((insertionSortMinPosFin r a l).succAbove i)) := byα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ ¬r (insertionSortDropMinPos r a l)[i] (insertionSortMin r a l)α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r (insertionSortDropMinPos r a l)[↑i] (a :: l)[↑(insertionSortMinPos r a l)]
    trans (insertionSortDropMinPos r a l).get iα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ (insertionSortDropMinPos r a l)[↑i] = (insertionSortDropMinPos r a l).get iα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ (insertionSortDropMinPos r a l).get i = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r (insertionSortDropMinPos r a l)[↑i] (a :: l)[↑(insertionSortMinPos r a l)]
    simp only [List.get_eq_getElem]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ (insertionSortDropMinPos r a l).get i = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r (insertionSortDropMinPos r a l)[↑i] (a :: l)[↑(insertionSortMinPos r a l)]
    simp only [insertionSortDropMinPos, List.length_cons, Nat.succ_eq_add_one, finCongr_apply]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ ((a :: l).eraseIdx ↑(insertionSortMinPos r a l)).get i =
  (a :: l).get (Fin.cast ⋯ ((insertionSortMinPosFin r a l).succAbove i))α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r (insertionSortDropMinPos r a l)[↑i] (a :: l)[↑(insertionSortMinPos r a l)]
    rw [eraseIdx_getα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ ((a :: l).get ∘ Fin.cast ⋯ ∘ (Fin.cast ⋯ (insertionSortMinPos r a l)).succAbove) i =
  (a :: l).get (Fin.cast ⋯ ((insertionSortMinPosFin r a l).succAbove i))α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ ((a :: l).get ∘ Fin.cast ⋯ ∘ (Fin.cast ⋯ (insertionSortMinPos r a l)).succAbove) i =
  (a :: l).get (Fin.cast ⋯ ((insertionSortMinPosFin r a l).succAbove i))α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r (insertionSortDropMinPos r a l)[↑i] (a :: l)[↑(insertionSortMinPos r a l)]]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ ((a :: l).get ∘ Fin.cast ⋯ ∘ (Fin.cast ⋯ (insertionSortMinPos r a l)).succAbove) i =
  (a :: l).get (Fin.cast ⋯ ((insertionSortMinPosFin r a l).succAbove i))α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r (insertionSortDropMinPos r a l)[↑i] (a :: l)[↑(insertionSortMinPos r a l)]
    simp only [List.length_cons, Function.comp_apply, List.get_eq_getElem, Fin.val_cast]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ (a :: l)[↑((Fin.cast ⋯ (insertionSortMinPos r a l)).succAbove i)] =
  (a :: l)[↑((insertionSortMinPosFin r a l).succAbove i)]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r (insertionSortDropMinPos r a l)[↑i] (a :: l)[↑(insertionSortMinPos r a l)]
    rflα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r (insertionSortDropMinPos r a l)[↑i] (a :: l)[↑(insertionSortMinPos r a l)]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r (insertionSortDropMinPos r a l)[↑i] (a :: l)[↑(insertionSortMinPos r a l)]
  rw [h1α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r ((a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))) (a :: l)[↑(insertionSortMinPos r a l)]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r ((a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))) (a :: l)[↑(insertionSortMinPos r a l)]]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r ((a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))) (a :: l)[↑(insertionSortMinPos r a l)]
  simp only [List.length_cons, Nat.succ_eq_add_one, List.get_eq_getElem]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬r (a :: l)[↑((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))] (a :: l)[↑(insertionSortMinPos r a l)]
  apply insertionSortEquiv_orderhijα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ (finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i) < insertionSortMinPos r a lhij'α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ (insertionSortEquiv r (a :: l)) (insertionSortMinPos r a l) <
  (insertionSortEquiv r (a :: l)) ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))
  exact hhij'α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ (insertionSortEquiv r (a :: l)) (insertionSortMinPos r a l) <
  (insertionSortEquiv r (a :: l)) ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))
  simp only [List.length_cons, finCongr_apply]hij'α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ (insertionSortEquiv r (a :: l)) (insertionSortMinPos r a l) <
  (insertionSortEquiv r (a :: l)) (Fin.cast ⋯ ((insertionSortMinPosFin r a l).succAbove i))
  apply lt_of_eq_of_lt (insertionSortMinPos_insertionSortEquiv r a l)hij'α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ⟨0, ⋯⟩ < (insertionSortEquiv r (a :: l)) (Fin.cast ⋯ ((insertionSortMinPosFin r a l).succAbove i))
  apply insertionSortEquiv_gt_zero_of_ne_insertionSortMinPos r a lhij'α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ Fin.cast ⋯ ((insertionSortMinPosFin r a l).succAbove i) ≠ insertionSortMinPos r a l
  simp only [List.length_cons, ne_eq, Fin.ext_iff, Fin.val_cast]hij'α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))⊢ ¬↑((insertionSortMinPosFin r a l).succAbove i) = ↑(insertionSortMinPos r a l)
  have hl : (insertionSortMinPos r a l).val = (insertionSortMinPosFin r a l).val := byα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a l⊢ ¬r (insertionSortDropMinPos r a l)[i] (insertionSortMin r a l)hij'α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))hl:↑(insertionSortMinPos r a l) = ↑(insertionSortMinPosFin r a l)⊢ ¬↑((insertionSortMinPosFin r a l).succAbove i) = ↑(insertionSortMinPos r a l)
    rflhij'α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))hl:↑(insertionSortMinPos r a l) = ↑(insertionSortMinPosFin r a l)⊢ ¬↑((insertionSortMinPosFin r a l).succAbove i) = ↑(insertionSortMinPos r a l)hij'α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))hl:↑(insertionSortMinPos r a l) = ↑(insertionSortMinPosFin r a l)⊢ ¬↑((insertionSortMinPosFin r a l).succAbove i) = ↑(insertionSortMinPos r a l)
  simp only [hl, Nat.succ_eq_add_one, Fin.val_eq_val, ne_eq]hij'α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αi:Fin (insertionSortDropMinPos r a l).lengthh:(insertionSortMinPosFin r a l).succAbove i < insertionSortMinPosFin r a lh1:(insertionSortDropMinPos r a l)[↑i] = (a :: l).get ((finCongr ⋯) ((insertionSortMinPosFin r a l).succAbove i))hl:↑(insertionSortMinPos r a l) = ↑(insertionSortMinPosFin r a l)⊢ ¬(insertionSortMinPosFin r a l).succAbove i = insertionSortMinPosFin r a l
  exact Fin.succAbove_ne (insertionSortMinPosFin r a l) iAll goals completed! 🐙lemma insertionSort_insertionSort {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (l1 : List α) :
    List.insertionSort r (List.insertionSort r l1) = List.insertionSort r l1 := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α rl1:List α⊢ List.insertionSort r (List.insertionSort r l1) = List.insertionSort r l1
  apply List.Pairwise.insertionSort_eqα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α rl1:List α⊢ List.Pairwise r (List.insertionSort r l1)
  exact List.pairwise_insertionSort r l1All goals completed! 🐙

lemma orderedInsert_commute {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (a b : α) (hr : ¬ r a b) : (l : List α) →
    List.orderedInsert r a (List.orderedInsert r b l) =
      List.orderedInsert r b (List.orderedInsert r a l)
  | [] =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a b⊢ List.orderedInsert r a (List.orderedInsert r b []) = List.orderedInsert r b (List.orderedInsert r a []) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a b⊢ List.orderedInsert r a (List.orderedInsert r b []) = List.orderedInsert r b (List.orderedInsert r a [])
    have hrb : r b a := (Std.Total.total a b).resolve_left hrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bhrb:r b a⊢ List.orderedInsert r a (List.orderedInsert r b []) = List.orderedInsert r b (List.orderedInsert r a [])
    simp [hr, hrb]All goals completed! 🐙
  | c :: l =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List α⊢ List.orderedInsert r a (List.orderedInsert r b (c :: l)) = List.orderedInsert r b (List.orderedInsert r a (c :: l)) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List α⊢ List.orderedInsert r a (List.orderedInsert r b (c :: l)) = List.orderedInsert r b (List.orderedInsert r a (c :: l))
    have hrb : r b a := (Std.Total.total a b).resolve_left hrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b a⊢ List.orderedInsert r a (List.orderedInsert r b (c :: l)) = List.orderedInsert r b (List.orderedInsert r a (c :: l))
    simp only [List.orderedInsert]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b a⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) =
  List.orderedInsert r b (if r a c then a :: c :: l else c :: List.orderedInsert r a l)
    by_cases h : r a cposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:r a c⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) =
  List.orderedInsert r b (if r a c then a :: c :: l else c :: List.orderedInsert r a l)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:¬r a c⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) =
  List.orderedInsert r b (if r a c then a :: c :: l else c :: List.orderedInsert r a l)
    ·posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:r a c⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) =
  List.orderedInsert r b (if r a c then a :: c :: l else c :: List.orderedInsert r a l) simp only [h, ↓reduceIte, List.orderedInsert.eq_2, hrb]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:r a c⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) = b :: a :: c :: l
      rw [if_pos (IsTrans.trans (r := r) _ _ _ hrb h)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:r a c⊢ List.orderedInsert r a (b :: c :: l) = b :: a :: c :: lposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:r a c⊢ List.orderedInsert r a (b :: c :: l) = b :: a :: c :: l]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:r a c⊢ List.orderedInsert r a (b :: c :: l) = b :: a :: c :: l
      simp only [List.orderedInsert, hr, ↓reduceIte, h]All goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:¬r a c⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) =
  List.orderedInsert r b (if r a c then a :: c :: l else c :: List.orderedInsert r a l) simp only [h, ↓reduceIte, List.orderedInsert.eq_2]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:¬r a c⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) =
  if r b c then b :: c :: List.orderedInsert r a l else c :: List.orderedInsert r b (List.orderedInsert r a l)
      by_cases hbc : r b cposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:¬r a chbc:r b c⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) =
  if r b c then b :: c :: List.orderedInsert r a l else c :: List.orderedInsert r b (List.orderedInsert r a l)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:¬r a chbc:¬r b c⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) =
  if r b c then b :: c :: List.orderedInsert r a l else c :: List.orderedInsert r b (List.orderedInsert r a l)
      ·posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:¬r a chbc:r b c⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) =
  if r b c then b :: c :: List.orderedInsert r a l else c :: List.orderedInsert r b (List.orderedInsert r a l) simp [hbc, hr, h]All goals completed! 🐙
      ·negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:¬r a chbc:¬r b c⊢ List.orderedInsert r a (if r b c then b :: c :: l else c :: List.orderedInsert r b l) =
  if r b c then b :: c :: List.orderedInsert r a l else c :: List.orderedInsert r b (List.orderedInsert r a l) simp only [hbc, ↓reduceIte, List.orderedInsert.eq_2, h, List.cons.injEq, true_and]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrb:r b ah:¬r a chbc:¬r b c⊢ List.orderedInsert r a (List.orderedInsert r b l) = List.orderedInsert r b (List.orderedInsert r a l)
        exact orderedInsert_commute r a b hr lAll goals completed! 🐙

lemma insertionSort_orderedInsert_append {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (a : α) : (l1 l2 : List α) →
    List.insertionSort r (List.orderedInsert r a l1 ++ l2) = List.insertionSort r (a :: l1 ++ l2)
  | [], l2 =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl2:List α⊢ List.insertionSort r (List.orderedInsert r a [] ++ l2) = List.insertionSort r ([a] ++ l2) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl2:List α⊢ List.insertionSort r (List.orderedInsert r a [] ++ l2) = List.insertionSort r ([a] ++ l2)
    simpAll goals completed! 🐙
  | b :: l1, l2 =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List α⊢ List.insertionSort r (List.orderedInsert r a (b :: l1) ++ l2) = List.insertionSort r (a :: b :: l1 ++ l2) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List α⊢ List.insertionSort r (List.orderedInsert r a (b :: l1) ++ l2) = List.insertionSort r (a :: b :: l1 ++ l2)
    conv_lhs => simpα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List α| List.insertionSort r ((if r a b then a :: b :: l1 else b :: List.orderedInsert r a l1) ++ l2)
    by_cases h : r a bposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αh:r a b⊢ List.insertionSort r ((if r a b then a :: b :: l1 else b :: List.orderedInsert r a l1) ++ l2) =
  List.insertionSort r (a :: b :: l1 ++ l2)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αh:¬r a b⊢ List.insertionSort r ((if r a b then a :: b :: l1 else b :: List.orderedInsert r a l1) ++ l2) =
  List.insertionSort r (a :: b :: l1 ++ l2)
    ·posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αh:r a b⊢ List.insertionSort r ((if r a b then a :: b :: l1 else b :: List.orderedInsert r a l1) ++ l2) =
  List.insertionSort r (a :: b :: l1 ++ l2) simp [h]All goals completed! 🐙
    conv_lhs => simp [h]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αh:¬r a b| List.orderedInsert r b (List.insertionSort r (List.orderedInsert r a l1 ++ l2))
    rw [insertionSort_orderedInsert_append r a l1 l2negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αh:¬r a b⊢ List.orderedInsert r b (List.insertionSort r (a :: l1 ++ l2)) = List.insertionSort r (a :: b :: l1 ++ l2)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αh:¬r a b⊢ List.orderedInsert r b (List.insertionSort r (a :: l1 ++ l2)) = List.insertionSort r (a :: b :: l1 ++ l2)]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αh:¬r a b⊢ List.orderedInsert r b (List.insertionSort r (a :: l1 ++ l2)) = List.insertionSort r (a :: b :: l1 ++ l2)
    simp only [List.cons_append, List.insertionSort_cons]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αh:¬r a b⊢ List.orderedInsert r b (List.orderedInsert r a (List.insertionSort r (l1 ++ l2))) =
  List.orderedInsert r a (List.orderedInsert r b (List.insertionSort r (l1 ++ l2)))
    rw [orderedInsert_commute r a b hnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αh:¬r a b⊢ List.orderedInsert r b (List.orderedInsert r a (List.insertionSort r (l1 ++ l2))) =
  List.orderedInsert r b (List.orderedInsert r a (List.insertionSort r (l1 ++ l2)))All goals completed! 🐙]All goals completed! 🐙

lemma insertionSort_insertionSort_append {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] : (l1 l2 : List α) →
    List.insertionSort r (List.insertionSort r l1 ++ l2) = List.insertionSort r (l1 ++ l2)
  | [], l2 =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α rl2:List α⊢ List.insertionSort r (List.insertionSort r [] ++ l2) = List.insertionSort r ([] ++ l2) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α rl2:List α⊢ List.insertionSort r (List.insertionSort r [] ++ l2) = List.insertionSort r ([] ++ l2)
    simpAll goals completed! 🐙
  | a :: l1, l2 =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ List.insertionSort r (List.insertionSort r (a :: l1) ++ l2) = List.insertionSort r (a :: l1 ++ l2) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ List.insertionSort r (List.insertionSort r (a :: l1) ++ l2) = List.insertionSort r (a :: l1 ++ l2)
    rw [List.insertionSort_cons,α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ List.insertionSort r (List.orderedInsert r a (List.insertionSort r l1) ++ l2) = List.insertionSort r (a :: l1 ++ l2)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ List.insertionSort r (a :: List.insertionSort r l1 ++ l2) = List.insertionSort r (a :: l1 ++ l2) insertionSort_orderedInsert_appendα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ List.insertionSort r (a :: List.insertionSort r l1 ++ l2) = List.insertionSort r (a :: l1 ++ l2)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ List.insertionSort r (a :: List.insertionSort r l1 ++ l2) = List.insertionSort r (a :: l1 ++ l2)]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ List.insertionSort r (a :: List.insertionSort r l1 ++ l2) = List.insertionSort r (a :: l1 ++ l2)
    simp only [List.cons_append, List.insertionSort_cons]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ List.orderedInsert r a (List.insertionSort r (List.insertionSort r l1 ++ l2)) =
  List.orderedInsert r a (List.insertionSort r (l1 ++ l2))
    rw [insertionSort_insertionSort_append r l1 l2α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ List.orderedInsert r a (List.insertionSort r (l1 ++ l2)) = List.orderedInsert r a (List.insertionSort r (l1 ++ l2))All goals completed! 🐙]All goals completed! 🐙

lemma insertionSort_append_insertionSort_append {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] : (l1 l2 l3 : List α) →
    List.insertionSort r (l1 ++ List.insertionSort r l2 ++ l3) =
      List.insertionSort r (l1 ++ l2 ++ l3)
  | [], l2, l3 =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α rl2:List αl3:List α⊢ List.insertionSort r ([] ++ List.insertionSort r l2 ++ l3) = List.insertionSort r ([] ++ l2 ++ l3) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α rl2:List αl3:List α⊢ List.insertionSort r ([] ++ List.insertionSort r l2 ++ l3) = List.insertionSort r ([] ++ l2 ++ l3)
    simpa using insertionSort_insertionSort_append r l2 l3All goals completed! 🐙
  | a :: l1, l2, l3 =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List αl3:List α⊢ List.insertionSort r (a :: l1 ++ List.insertionSort r l2 ++ l3) = List.insertionSort r (a :: l1 ++ l2 ++ l3) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List αl3:List α⊢ List.insertionSort r (a :: l1 ++ List.insertionSort r l2 ++ l3) = List.insertionSort r (a :: l1 ++ l2 ++ l3)
    simp only [List.cons_append, List.insertionSort_cons]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List αl3:List α⊢ List.orderedInsert r a (List.insertionSort r (l1 ++ List.insertionSort r l2 ++ l3)) =
  List.orderedInsert r a (List.insertionSort r (l1 ++ l2 ++ l3))
    rw [insertionSort_append_insertionSort_append r l1 l2 l3α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List αl3:List α⊢ List.orderedInsert r a (List.insertionSort r (l1 ++ l2 ++ l3)) =
  List.orderedInsert r a (List.insertionSort r (l1 ++ l2 ++ l3))All goals completed! 🐙]All goals completed! 🐙@[simp]
lemma orderedInsert_length {α : Type} (r : α → α → Prop) [DecidableRel r] (a : α) (l : List α) :
    (List.orderedInsert r a l).length = (a :: l).length := byα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (List.orderedInsert r a l).length = (a :: l).length
  apply List.Perm.length_eqα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (List.orderedInsert r a l).Perm (a :: l)
  exact List.perm_orderedInsert r a lAll goals completed! 🐙lemma takeWhile_orderedInsert {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r]
    (a b : α) (hr : ¬ r a b) : (l : List α) →
    (List.takeWhile (fun c => !decide (r a c)) (List.orderedInsert r b l)).length =
    (List.takeWhile (fun c => !decide (r a c)) l).length + 1
  | [] =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a b⊢ (List.takeWhile (fun c => !decide (r a c)) (List.orderedInsert r b [])).length =
  (List.takeWhile (fun c => !decide (r a c)) []).length + 1 byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a b⊢ (List.takeWhile (fun c => !decide (r a c)) (List.orderedInsert r b [])).length =
  (List.takeWhile (fun c => !decide (r a c)) []).length + 1
    simp [hr]All goals completed! 🐙
  | c :: l =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List α⊢ (List.takeWhile (fun c => !decide (r a c)) (List.orderedInsert r b (c :: l))).length =
  (List.takeWhile (fun c => !decide (r a c)) (c :: l)).length + 1 byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List α⊢ (List.takeWhile (fun c => !decide (r a c)) (List.orderedInsert r b (c :: l))).length =
  (List.takeWhile (fun c => !decide (r a c)) (c :: l)).length + 1
    simp only [List.orderedInsert]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List α⊢ (List.takeWhile (fun c => !decide (r a c)) (if r b c then b :: c :: l else c :: List.orderedInsert r b l)).length =
  (List.takeWhile (fun c => !decide (r a c)) (c :: l)).length + 1
    by_cases h : r b cposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αh:r b c⊢ (List.takeWhile (fun c => !decide (r a c)) (if r b c then b :: c :: l else c :: List.orderedInsert r b l)).length =
  (List.takeWhile (fun c => !decide (r a c)) (c :: l)).length + 1negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αh:¬r b c⊢ (List.takeWhile (fun c => !decide (r a c)) (if r b c then b :: c :: l else c :: List.orderedInsert r b l)).length =
  (List.takeWhile (fun c => !decide (r a c)) (c :: l)).length + 1
    ·posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αh:r b c⊢ (List.takeWhile (fun c => !decide (r a c)) (if r b c then b :: c :: l else c :: List.orderedInsert r b l)).length =
  (List.takeWhile (fun c => !decide (r a c)) (c :: l)).length + 1 simp [h, hr]All goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αh:¬r b c⊢ (List.takeWhile (fun c => !decide (r a c)) (if r b c then b :: c :: l else c :: List.orderedInsert r b l)).length =
  (List.takeWhile (fun c => !decide (r a c)) (c :: l)).length + 1 simp only [h, ↓reduceIte]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αh:¬r b c⊢ (List.takeWhile (fun c => !decide (r a c)) (c :: List.orderedInsert r b l)).length =
  (List.takeWhile (fun c => !decide (r a c)) (c :: l)).length + 1
      have hl : ¬ r a c :=
        fun hn => h (IsTrans.trans _ _ _ ((Std.Total.total a b).resolve_left hr) hn)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αh:¬r b chl:¬r a c⊢ (List.takeWhile (fun c => !decide (r a c)) (c :: List.orderedInsert r b l)).length =
  (List.takeWhile (fun c => !decide (r a c)) (c :: l)).length + 1
      simp only [hl, decide_false, Bool.not_false, List.takeWhile_cons_of_pos, List.length_cons,
        add_left_inj]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αh:¬r b chl:¬r a c⊢ (List.takeWhile (fun c => !decide (r a c)) (List.orderedInsert r b l)).length =
  (List.takeWhile (fun c => !decide (r a c)) l).length + 1
      exact takeWhile_orderedInsert r a b hr lAll goals completed! 🐙lemma takeWhile_orderedInsert' {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r]
    (a b : α) (hr : ¬ r a b) : (l : List α) →
    (List.takeWhile (fun c => !decide (r b c)) (List.orderedInsert r a l)).length =
    (List.takeWhile (fun c => !decide (r b c)) l).length
  | [] =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a b⊢ (List.takeWhile (fun c => !decide (r b c)) (List.orderedInsert r a [])).length =
  (List.takeWhile (fun c => !decide (r b c)) []).length byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a b⊢ (List.takeWhile (fun c => !decide (r b c)) (List.orderedInsert r a [])).length =
  (List.takeWhile (fun c => !decide (r b c)) []).length
    simp [List.orderedInsert, (Std.Total.total a b).resolve_left hr]All goals completed! 🐙
  | c :: l =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List α⊢ (List.takeWhile (fun c => !decide (r b c)) (List.orderedInsert r a (c :: l))).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List α⊢ (List.takeWhile (fun c => !decide (r b c)) (List.orderedInsert r a (c :: l))).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length
    have hrba : r b a := (Std.Total.total a b).resolve_left hrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b a⊢ (List.takeWhile (fun c => !decide (r b c)) (List.orderedInsert r a (c :: l))).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length
    simp only [List.orderedInsert]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b a⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length
    by_cases h : r b cposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:r b c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).lengthnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:¬r b c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length
    ·posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:r b c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length by_cases hac : r a cposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:r b chac:r a c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).lengthnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:r b chac:¬r a c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length <;>posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:r b chac:r a c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).lengthnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:r b chac:¬r a c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length simp [h, hac, hrba]All goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:¬r b c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length by_cases hac : r a cposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:¬r b chac:r a c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).lengthnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:¬r b chac:¬r a c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length
      ·posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:¬r b chac:r a c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length exact absurd (IsTrans.trans _ _ _ hrba hac) hAll goals completed! 🐙
      ·negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:¬r b chac:¬r a c⊢ (List.takeWhile (fun c => !decide (r b c)) (if r a c then a :: c :: l else c :: List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (c :: l)).length simp only [hac, ↓reduceIte, h, decide_false, Bool.not_false, List.takeWhile_cons_of_pos,
        List.length_cons, add_left_inj]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bc:αl:List αhrba:r b ah:¬r b chac:¬r a c⊢ (List.takeWhile (fun c => !decide (r b c)) (List.orderedInsert r a l)).length =
  (List.takeWhile (fun c => !decide (r b c)) l).length
        exact takeWhile_orderedInsert' r a b hr lAll goals completed! 🐙

set_option backward.isDefEq.respectTransparency false in
lemma insertionSortEquiv_commute {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (a b : α) (hr : ¬ r a b) (n : ℕ) : (l : List α) →
    (hn : n + 2 < (a :: b :: l).length) →
    insertionSortEquiv r (a :: b :: l) ⟨n + 2, hn⟩ = (finCongr (byn✝:ℕα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕl:List αhn:n + 2 < (a :: b :: l).length⊢ (List.insertionSort r (b :: a :: l)).length = (List.insertionSort r (a :: b :: l)).length simpAll goals completed! 🐙))
    (insertionSortEquiv r (b :: a :: l) ⟨n + 2, hn⟩) := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕ⊢ ∀ (l : List α) (hn : n + 2 < (a :: b :: l).length),
  (insertionSortEquiv r (a :: b :: l)) ⟨n + 2, hn⟩ = (finCongr ⋯) ((insertionSortEquiv r (b :: a :: l)) ⟨n + 2, hn⟩)
  have hrba : r b a := (Std.Total.total a b).resolve_left hrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b a⊢ ∀ (l : List α) (hn : n + 2 < (a :: b :: l).length),
  (insertionSortEquiv r (a :: b :: l)) ⟨n + 2, hn⟩ = (finCongr ⋯) ((insertionSortEquiv r (b :: a :: l)) ⟨n + 2, hn⟩)
  intro l hnα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length⊢ (insertionSortEquiv r (a :: b :: l)) ⟨n + 2, hn⟩ = (finCongr ⋯) ((insertionSortEquiv r (b :: a :: l)) ⟨n + 2, hn⟩)
  simp only [List.insertionSort, List.length_cons, insertionSortEquiv, Nat.succ_eq_add_one,
    equivCons_trans, Equiv.trans_apply, equivCons_succ, finCongr_apply]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length⊢ (orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (b :: l)) a)
    ((equivCons (orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) b))
      ((insertionSortEquiv r l) ⟨n, ⋯⟩).succ.succ) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (a :: l)) b)
      ((equivCons (orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) a))
        ((insertionSortEquiv r l) ⟨n, ⋯⟩).succ.succ))
  conv_lhs => erw [equivCons_succ]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length| (orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (b :: l)) a)
  ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) b) ⟨↑((insertionSortEquiv r l).1 ⟨n, ⋯⟩) + 1, ⋯⟩).succ
  conv_rhs => erw [equivCons_succ]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length| Fin.cast ⋯
  ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (a :: l)) b)
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) a)
        ⟨↑((insertionSortEquiv r l).1 ⟨n, ⋯⟩) + 1, ⋯⟩).succ)
  simp only [Equiv.toFun_as_coe]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length⊢ (orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (b :: l)) a)
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) b)
        ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩) + 1, ⋯⟩).succ =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (a :: l)) b)
      ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) a)
          ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩) + 1, ⋯⟩).succ)
  conv_lhs =>
    rhsα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length| ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) b) ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩) + 1, ⋯⟩).succ
    rhsα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length| (orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) b) ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩) + 1, ⋯⟩
    erw [orderedInsertEquiv_succ]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length| Fin.cast ⋯
  (⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
    ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩), ⋯⟩)
  conv_lhs => erw [orderedInsertEquiv_fin_succ]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length| Fin.cast ⋯
  (⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
    ⟨↑(Fin.cast ⋯
          (⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩), ⋯⟩)),
      ⋯⟩)
  simp only [Fin.eta, Fin.val_cast]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length⊢ Fin.cast ⋯
    (⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (a :: l)) b)
      ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) a)
          ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩) + 1, ⋯⟩).succ)
  conv_rhs =>
    rhsα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length| (orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (a :: l)) b)
  ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) a) ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩) + 1, ⋯⟩).succ
    rhsα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length| ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] l) a) ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩) + 1, ⋯⟩).succ
    erw [orderedInsertEquiv_succ]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length| (Fin.cast ⋯
    (⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
      ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩), ⋯⟩)).succ
  conv_rhs => erw [orderedInsertEquiv_fin_succ]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length| Fin.cast ⋯
  (Fin.cast ⋯
    (⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(Fin.cast ⋯
            (⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
              ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩), ⋯⟩)),
        ⋯⟩))
  extα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length⊢ ↑(Fin.cast ⋯
      (⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
        ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
              ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
          ⋯⟩)) =
  ↑(Fin.cast ⋯
      (Fin.cast ⋯
        (⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
          ⟨↑(Fin.cast ⋯
                (⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
                  ⟨↑((insertionSortEquiv r l) ⟨n, ⋯⟩), ⋯⟩)),
            ⋯⟩)))
  simp only [Fin.val_cast, Fin.eta, Fin.cast_cast]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).length⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
  let a1 : Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) :=
    ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a),
      orderedInsertPos_lt_length r (List.orderedInsert r b (List.insertionSort r l)) a⟩α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
  let b1 : Fin ((List.insertionSort r l).length + 1) :=
    ⟨↑(orderedInsertPos r (List.insertionSort r l) b),
      orderedInsertPos_lt_length r (List.insertionSort r l) b⟩α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
  let a2 : Fin ((List.insertionSort r l).length + 1) :=
    ⟨↑(orderedInsertPos r (List.insertionSort r l) a),
      orderedInsertPos_lt_length r (List.insertionSort r l) a⟩α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
  let b2 : Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) :=
    ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b),
      orderedInsertPos_lt_length r (List.orderedInsert r a (List.insertionSort r l)) b⟩α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
  have ht : (List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l))
      = (List.takeWhile (fun c => !decide (r b c))
        ((List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l)))) := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕ⊢ ∀ (l : List α) (hn : n + 2 < (a :: b :: l).length),
  (insertionSortEquiv r (a :: b :: l)) ⟨n + 2, hn⟩ = (finCongr ⋯) ((insertionSortEquiv r (b :: a :: l)) ⟨n + 2, hn⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
      rw [List.takeWhile_takeWhileα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩⊢ List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun a_1 => decide ((!decide (r b a_1)) = true ∧ (!decide (r a a_1)) = true)) (List.insertionSort r l)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩⊢ List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun a_1 => decide ((!decide (r b a_1)) = true ∧ (!decide (r a a_1)) = true)) (List.insertionSort r l)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩⊢ List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun a_1 => decide ((!decide (r b a_1)) = true ∧ (!decide (r a a_1)) = true)) (List.insertionSort r l)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
      simp only [Bool.not_eq_eq_eq_not, Bool.not_true, decide_eq_false_iff_not, Bool.decide_and,
        decide_not]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩⊢ List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun a_1 => !decide (r b a_1) && !decide (r a a_1)) (List.insertionSort r l)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
      congre_pα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩⊢ (fun c => !decide (r b c)) = fun a_1 => !decide (r b a_1) && !decide (r a a_1)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
      funext ce_pα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩c:α⊢ (!decide (r b c)) = (!decide (r b c) && !decide (r a c))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
      simp only [Bool.eq_self_and, Bool.not_eq_eq_eq_not, Bool.not_true, decide_eq_false_iff_not]e_pα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩c:α⊢ ¬r b c → ¬r a cα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
      intro hbc hace_pα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩c:αhbc:¬r b chac:r a c⊢ Falseα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
      refine hbc ?_e_pα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩c:αhbc:¬r b chac:r a c⊢ r b cα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
      exact IsTrans.trans _ _ _ hrba hacα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
  have ha1 : b1.1 ≤ a2.1 := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕ⊢ ∀ (l : List α) (hn : n + 2 < (a :: b :: l).length),
  (insertionSortEquiv r (a :: b :: l)) ⟨n + 2, hn⟩ = (finCongr ⋯) ((insertionSortEquiv r (b :: a :: l)) ⟨n + 2, hn⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    simp only [orderedInsertPos, decide_not, b1]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ (List.takeWhile (fun b_1 => !decide (r b b_1)) (List.insertionSort r l)).length ≤ ↑a2α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    rw [htα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ (List.takeWhile (fun c => !decide (r b c))
      (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))).length ≤
  ↑a2α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ (List.takeWhile (fun c => !decide (r b c))
      (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))).length ≤
  ↑a2α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ (List.takeWhile (fun c => !decide (r b c))
      (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))).length ≤
  ↑a2α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    apply List.Sublist.length_leα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ (List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))).Sublist
  (List.takeWhile (fun b => decide ¬r a b) (List.insertionSort r l))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    simp only [decide_not]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))⊢ (List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))).Sublist
  (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    exact List.takeWhile_sublist _α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
  have ha2 : a1.1 = a2.1 + 1 := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕ⊢ ∀ (l : List α) (hn : n + 2 < (a :: b :: l).length),
  (insertionSortEquiv r (a :: b :: l)) ⟨n + 2, hn⟩ = (finCongr ⋯) ((insertionSortEquiv r (b :: a :: l)) ⟨n + 2, hn⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    simp only [orderedInsertPos, decide_not, a1, a2]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ (List.takeWhile (fun b => !decide (r a b)) (List.orderedInsert r b (List.insertionSort r l))).length =
  (List.takeWhile (fun b => !decide (r a b)) (List.insertionSort r l)).length + 1α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    rw [takeWhile_orderedInsertα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l)).length + 1 =
  (List.takeWhile (fun b => !decide (r a b)) (List.insertionSort r l)).length + 1hrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ¬r a bhrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ¬r a bα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)]hrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2⊢ ¬r a bα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    exact hrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
  have hb : b1.1 = b2.1 := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕ⊢ ∀ (l : List α) (hn : n + 2 < (a :: b :: l).length),
  (insertionSortEquiv r (a :: b :: l)) ⟨n + 2, hn⟩ = (finCongr ⋯) ((insertionSortEquiv r (b :: a :: l)) ⟨n + 2, hn⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    simp only [orderedInsertPos, decide_not, b1, b2]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ (List.takeWhile (fun b_1 => !decide (r b b_1)) (List.insertionSort r l)).length =
  (List.takeWhile (fun b_1 => !decide (r b b_1)) (List.orderedInsert r a (List.insertionSort r l))).lengthα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    rw [takeWhile_orderedInsert'α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ (List.takeWhile (fun b_1 => !decide (r b b_1)) (List.insertionSort r l)).length =
  (List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l)).lengthhrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ ¬r a bhrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ ¬r a bα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)]hrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1⊢ ¬r a bα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
    exact hrα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
  let n := ((insertionSortEquiv r l) ⟨n, byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2⊢ n < l.lengthα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) simpa using hnAll goals completed! 🐙α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩⊢ ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (b :: l)) a), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) b), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩) =
  ↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] (a :: l)) b), ⋯⟩.succAbove
      ⟨↑(⟨↑(orderedInsertPos r (List.foldr (List.orderedInsert r) [] l) a), ⋯⟩.succAbove
            ((insertionSortEquiv r l) ⟨n, ⋯⟩)),
        ⋯⟩)
  change (a1.succAbove ⟨b1.succAbove n, _⟩).1 = (b2.succAbove ⟨a2.succAbove n, _⟩).1α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩⊢ ↑(a1.succAbove ⟨↑(b1.succAbove n), ⋯⟩) = ↑(b2.succAbove ⟨↑(a2.succAbove n), ⋯⟩)
  have hba : b2.1 ≤ a2.1 := hb ▸ ha1α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2⊢ ↑(a1.succAbove ⟨↑(b1.succAbove n), ⋯⟩) = ↑(b2.succAbove ⟨↑(a2.succAbove n), ⋯⟩)
  have val_succAbove {m : ℕ} (p : Fin (m + 1)) (i : Fin m) :
      (p.succAbove i).1 = if i.1 < p.1 then i.1 else i.1 + 1 := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn:ℕ⊢ ∀ (l : List α) (hn : n + 2 < (a :: b :: l).length),
  (insertionSortEquiv r (a :: b :: l)) ⟨n + 2, hn⟩ = (finCongr ⋯) ((insertionSortEquiv r (b :: a :: l)) ⟨n + 2, hn⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1⊢ ↑(a1.succAbove ⟨↑(b1.succAbove n), ⋯⟩) = ↑(b2.succAbove ⟨↑(a2.succAbove n), ⋯⟩)
    rw [Fin.succAboveα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2m:ℕp:Fin (m + 1)i:Fin m⊢ ↑(if i.castSucc < p then i.castSucc else i.succ) = if ↑i < ↑p then ↑i else ↑i + 1α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2m:ℕp:Fin (m + 1)i:Fin m⊢ ↑(if i.castSucc < p then i.castSucc else i.succ) = if ↑i < ↑p then ↑i else ↑i + 1α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1⊢ ↑(a1.succAbove ⟨↑(b1.succAbove n), ⋯⟩) = ↑(b2.succAbove ⟨↑(a2.succAbove n), ⋯⟩)]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2m:ℕp:Fin (m + 1)i:Fin m⊢ ↑(if i.castSucc < p then i.castSucc else i.succ) = if ↑i < ↑p then ↑i else ↑i + 1α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1⊢ ↑(a1.succAbove ⟨↑(b1.succAbove n), ⋯⟩) = ↑(b2.succAbove ⟨↑(a2.succAbove n), ⋯⟩)
    splitisTrueα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2m:ℕp:Fin (m + 1)i:Fin mh✝:i.castSucc < p⊢ ↑i.castSucc = if ↑i < ↑p then ↑i else ↑i + 1isFalseα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2m:ℕp:Fin (m + 1)i:Fin mh✝:¬i.castSucc < p⊢ ↑i.succ = if ↑i < ↑p then ↑i else ↑i + 1α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1⊢ ↑(a1.succAbove ⟨↑(b1.succAbove n), ⋯⟩) = ↑(b2.succAbove ⟨↑(a2.succAbove n), ⋯⟩) <;>isTrueα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2m:ℕp:Fin (m + 1)i:Fin mh✝:i.castSucc < p⊢ ↑i.castSucc = if ↑i < ↑p then ↑i else ↑i + 1isFalseα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2m:ℕp:Fin (m + 1)i:Fin mh✝:¬i.castSucc < p⊢ ↑i.succ = if ↑i < ↑p then ↑i else ↑i + 1α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1⊢ ↑(a1.succAbove ⟨↑(b1.succAbove n), ⋯⟩) = ↑(b2.succAbove ⟨↑(a2.succAbove n), ⋯⟩) simp_all [Fin.lt_def]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1⊢ ↑(a1.succAbove ⟨↑(b1.succAbove n), ⋯⟩) = ↑(b2.succAbove ⟨↑(a2.succAbove n), ⋯⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1⊢ ↑(a1.succAbove ⟨↑(b1.succAbove n), ⋯⟩) = ↑(b2.succAbove ⟨↑(a2.succAbove n), ⋯⟩)
  simp only [val_succAbove, ha2, hb]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1⊢ (if (if ↑n < ↑b2 then ↑n else ↑n + 1) < ↑a2 + 1 then if ↑n < ↑b2 then ↑n else ↑n + 1
  else (if ↑n < ↑b2 then ↑n else ↑n + 1) + 1) =
  if (if ↑n < ↑a2 then ↑n else ↑n + 1) < ↑b2 then if ↑n < ↑a2 then ↑n else ↑n + 1
  else (if ↑n < ↑a2 then ↑n else ↑n + 1) + 1
  split_ifsposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝²:↑n < ↑b2h✝¹:↑n < ↑a2 + 1h✝:↑n < ↑a2⊢ ↑n = ↑nposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:↑n < ↑b2h✝²:↑n < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:↑n + 1 < ↑b2⊢ ↑n = ↑n + 1negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:↑n < ↑b2h✝²:↑n < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:¬↑n + 1 < ↑b2⊢ ↑n = ↑n + 1 + 1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝²:↑n < ↑b2h✝¹:¬↑n < ↑a2 + 1h✝:↑n < ↑a2⊢ ↑n + 1 = ↑nposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:↑n < ↑b2h✝²:¬↑n < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:↑n + 1 < ↑b2⊢ ↑n + 1 = ↑n + 1negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:↑n < ↑b2h✝²:¬↑n < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:¬↑n + 1 < ↑b2⊢ ↑n + 1 = ↑n + 1 + 1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝²:¬↑n < ↑b2h✝¹:↑n + 1 < ↑a2 + 1h✝:↑n < ↑a2⊢ ↑n + 1 = ↑n + 1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:¬↑n < ↑b2h✝²:↑n + 1 < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:↑n + 1 < ↑b2⊢ ↑n + 1 = ↑n + 1negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:¬↑n < ↑b2h✝²:↑n + 1 < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:¬↑n + 1 < ↑b2⊢ ↑n + 1 = ↑n + 1 + 1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝²:¬↑n < ↑b2h✝¹:¬↑n + 1 < ↑a2 + 1h✝:↑n < ↑a2⊢ ↑n + 1 + 1 = ↑n + 1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:¬↑n < ↑b2h✝²:¬↑n + 1 < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:↑n + 1 < ↑b2⊢ ↑n + 1 + 1 = ↑n + 1negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:¬↑n < ↑b2h✝²:¬↑n + 1 < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:¬↑n + 1 < ↑b2⊢ ↑n + 1 + 1 = ↑n + 1 + 1 <;>posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝²:↑n < ↑b2h✝¹:↑n < ↑a2 + 1h✝:↑n < ↑a2⊢ ↑n = ↑nposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:↑n < ↑b2h✝²:↑n < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:↑n + 1 < ↑b2⊢ ↑n = ↑n + 1negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:↑n < ↑b2h✝²:↑n < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:¬↑n + 1 < ↑b2⊢ ↑n = ↑n + 1 + 1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝²:↑n < ↑b2h✝¹:¬↑n < ↑a2 + 1h✝:↑n < ↑a2⊢ ↑n + 1 = ↑nposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:↑n < ↑b2h✝²:¬↑n < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:↑n + 1 < ↑b2⊢ ↑n + 1 = ↑n + 1negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:↑n < ↑b2h✝²:¬↑n < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:¬↑n + 1 < ↑b2⊢ ↑n + 1 = ↑n + 1 + 1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝²:¬↑n < ↑b2h✝¹:↑n + 1 < ↑a2 + 1h✝:↑n < ↑a2⊢ ↑n + 1 = ↑n + 1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:¬↑n < ↑b2h✝²:↑n + 1 < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:↑n + 1 < ↑b2⊢ ↑n + 1 = ↑n + 1negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:¬↑n < ↑b2h✝²:↑n + 1 < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:¬↑n + 1 < ↑b2⊢ ↑n + 1 = ↑n + 1 + 1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝²:¬↑n < ↑b2h✝¹:¬↑n + 1 < ↑a2 + 1h✝:↑n < ↑a2⊢ ↑n + 1 + 1 = ↑n + 1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:¬↑n < ↑b2h✝²:¬↑n + 1 < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:↑n + 1 < ↑b2⊢ ↑n + 1 + 1 = ↑n + 1negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αhr:¬r a bn✝:ℕhrba:r b al:List αhn:n + 2 < (a :: b :: l).lengtha1:Fin ((List.orderedInsert r b (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r b (List.insertionSort r l)) a), ⋯⟩b1:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) b), ⋯⟩a2:Fin ((List.insertionSort r l).length + 1) := ⟨↑(orderedInsertPos r (List.insertionSort r l) a), ⋯⟩b2:Fin ((List.orderedInsert r a (List.insertionSort r l)).length + 1) := ⟨↑(orderedInsertPos r (List.orderedInsert r a (List.insertionSort r l)) b), ⋯⟩ht:List.takeWhile (fun c => !decide (r b c)) (List.insertionSort r l) =
  List.takeWhile (fun c => !decide (r b c)) (List.takeWhile (fun c => !decide (r a c)) (List.insertionSort r l))ha1:↑b1 ≤ ↑a2ha2:↑a1 = ↑a2 + 1hb:↑b1 = ↑b2n:Fin (List.insertionSort r l).length := (insertionSortEquiv r l) ⟨n✝, ⋯⟩hba:↑b2 ≤ ↑a2val_succAbove:∀ {m : ℕ} (p : Fin (m + 1)) (i : Fin m), ↑(p.succAbove i) = if ↑i < ↑p then ↑i else ↑i + 1h✝³:¬↑n < ↑b2h✝²:¬↑n + 1 < ↑a2 + 1h✝¹:¬↑n < ↑a2h✝:¬↑n + 1 < ↑b2⊢ ↑n + 1 + 1 = ↑n + 1 + 1 omegaAll goals completed! 🐙

set_option backward.isDefEq.respectTransparency false in
lemma insertionSortEquiv_orderedInsert_append {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (a a2 : α) : (l1 l2 : List α) →
    (insertionSortEquiv r (List.orderedInsert r a l1 ++ a2 :: l2) ⟨l1.length + 1, byn:ℕα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αl1:List αl2:List α⊢ l1.length + 1 < (List.orderedInsert r a l1 ++ a2 :: l2).length
      simpAll goals completed! 🐙⟩)
    = (finCongr (byn:ℕα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αl1:List αl2:List α⊢ (List.insertionSort r (a :: l1 ++ a2 :: l2)).length =
  (List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2)).length
      simp only [List.cons_append, List.insertionSort_cons, orderedInsert_length, List.length_cons,
        List.length_insertionSort, List.length_append]n:ℕα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αl1:List αl2:List α⊢ l1.length + (l2.length + 1) + 1 = l1.length + 1 + (l2.length + 1)
      omegaAll goals completed! 🐙))
      ((insertionSortEquiv r (a :: l1 ++ a2 :: l2)) ⟨l1.length + 1, byn:ℕα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αl1:List αl2:List α⊢ l1.length + 1 < (a :: l1 ++ a2 :: l2).length simpAll goals completed! 🐙⟩)
  | [], l2 =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αl2:List α⊢ (insertionSortEquiv r (List.orderedInsert r a [] ++ a2 :: l2)) ⟨[].length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r ([a] ++ a2 :: l2)) ⟨[].length + 1, ⋯⟩) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αl2:List α⊢ (insertionSortEquiv r (List.orderedInsert r a [] ++ a2 :: l2)) ⟨[].length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r ([a] ++ a2 :: l2)) ⟨[].length + 1, ⋯⟩)
    simp only [List.insertionSort, List.length_nil, zero_add, Fin.mk_one, List.cons_append,
      List.nil_append, List.foldr_cons, finCongr_refl, List.length_cons]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αl2:List α⊢ (insertionSortEquiv r (List.orderedInsert r a [] ++ a2 :: l2)) 1 =
  (Equiv.refl (Fin (List.orderedInsert r a (List.orderedInsert r a2 (List.foldr (List.orderedInsert r) [] l2))).length))
    ((insertionSortEquiv r (a :: a2 :: l2)) 1)
    rflAll goals completed! 🐙
  | b :: l1, l2 =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List α⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List α⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)
    by_cases h : r a bposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:r a b⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a b⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)
    ·posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:r a b⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩) have h1 : (List.orderedInsert r a (b :: l1) ++ a2 :: l2) = (a :: b :: l1 ++ a2 :: l2) := by
        simp [h]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = a :: b :: l1 ++ a2 :: l2⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = a :: b :: l1 ++ a2 :: l2⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)
      rw [insertionSortEquiv_congr _ _ h1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = a :: b :: l1 ++ a2 :: l2⊢ ((Fin.castOrderIso ⋯).trans ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)).trans (Fin.castOrderIso ⋯).toEquiv))
    ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = a :: b :: l1 ++ a2 :: l2⊢ ((Fin.castOrderIso ⋯).trans ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)).trans (Fin.castOrderIso ⋯).toEquiv))
    ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = a :: b :: l1 ++ a2 :: l2⊢ ((Fin.castOrderIso ⋯).trans ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)).trans (Fin.castOrderIso ⋯).toEquiv))
    ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)
      simpAll goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a b⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩) have h1 : (List.orderedInsert r a (b :: l1) ++ a2 :: l2) =
        (b :: List.orderedInsert r a (l1) ++ a2 :: l2) := by
        simp [h]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)
      rw [insertionSortEquiv_congr _ _ h1negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2⊢ ((Fin.castOrderIso ⋯).trans
      ((insertionSortEquiv r (b :: List.orderedInsert r a l1 ++ a2 :: l2)).trans (Fin.castOrderIso ⋯).toEquiv))
    ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2⊢ ((Fin.castOrderIso ⋯).trans
      ((insertionSortEquiv r (b :: List.orderedInsert r a l1 ++ a2 :: l2)).trans (Fin.castOrderIso ⋯).toEquiv))
    ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2⊢ ((Fin.castOrderIso ⋯).trans
      ((insertionSortEquiv r (b :: List.orderedInsert r a l1 ++ a2 :: l2)).trans (Fin.castOrderIso ⋯).toEquiv))
    ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)
      simp only [List.cons_append, List.length_cons,
        Equiv.trans_apply, RelIso.coe_fn_toEquiv, Fin.castOrderIso_apply, Fin.cast_mk,
        finCongr_apply]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2⊢ Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.orderedInsert r a l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)
      conv_lhs => simp [insertionSortEquiv]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2| Fin.cast ⋯
  ((orderedInsertEquiv r (List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2)) b)
    ((insertionSortEquiv r (List.orderedInsert r a l1 ++ a2 :: l2)) ⟨l1.length + 1, ⋯⟩).succ)
      rw [insertionSortEquiv_orderedInsert_append r anegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2)) b)
      ((finCongr ⋯) ((insertionSortEquiv r (a :: l1 ++ a2 :: l2)) ⟨l1.length + 1, ⋯⟩)).succ) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2)) b)
      ((finCongr ⋯) ((insertionSortEquiv r (a :: l1 ++ a2 :: l2)) ⟨l1.length + 1, ⋯⟩)).succ) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2)) b)
      ((finCongr ⋯) ((insertionSortEquiv r (a :: l1 ++ a2 :: l2)) ⟨l1.length + 1, ⋯⟩)).succ) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)
      have hl : (List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2)) =
        List.insertionSort r (a :: l1 ++ a2 :: l2) :=
        insertionSort_orderedInsert_append r a l1 (a2 :: l2)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2)) b)
      ((finCongr ⋯) ((insertionSortEquiv r (a :: l1 ++ a2 :: l2)) ⟨l1.length + 1, ⋯⟩)).succ) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)
      rw [orderedInsertEquiv_congr _ _ _ hlnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)⊢ Fin.cast ⋯
    (((Fin.castOrderIso ⋯).trans
        ((orderedInsertEquiv r (List.insertionSort r (a :: l1 ++ a2 :: l2)) b).trans (Fin.castOrderIso ⋯).toEquiv))
      ((finCongr ⋯) ((insertionSortEquiv r (a :: l1 ++ a2 :: l2)) ⟨l1.length + 1, ⋯⟩)).succ) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)⊢ Fin.cast ⋯
    (((Fin.castOrderIso ⋯).trans
        ((orderedInsertEquiv r (List.insertionSort r (a :: l1 ++ a2 :: l2)) b).trans (Fin.castOrderIso ⋯).toEquiv))
      ((finCongr ⋯) ((insertionSortEquiv r (a :: l1 ++ a2 :: l2)) ⟨l1.length + 1, ⋯⟩)).succ) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)⊢ Fin.cast ⋯
    (((Fin.castOrderIso ⋯).trans
        ((orderedInsertEquiv r (List.insertionSort r (a :: l1 ++ a2 :: l2)) b).trans (Fin.castOrderIso ⋯).toEquiv))
      ((finCongr ⋯) ((insertionSortEquiv r (a :: l1 ++ a2 :: l2)) ⟨l1.length + 1, ⋯⟩)).succ) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)
      conv_lhs =>
        enter [2, 1, 2, 1]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)| orderedInsertEquiv r (List.insertionSort r (a :: l1 ++ a2 :: l2)) b
        simp [List.insertionSort_cons]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)| orderedInsertEquiv r (List.insertionSort r (a :: (l1 ++ a2 :: l2))) b
      simp only [List.insertionSort, List.foldr_cons, List.cons_append, List.length_cons,
        finCongr_apply, Equiv.trans_apply, RelIso.coe_fn_toEquiv, Fin.castOrderIso_apply,
        Fin.cast_succ_eq, Fin.cast_cast, Fin.cast_eq_self]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.orderedInsert r a (List.foldr (List.orderedInsert r) [] (l1 ++ a2 :: l2))) b)
      ((insertionSortEquiv r (a :: (l1 ++ a2 :: l2))) ⟨l1.length + 1, ⋯⟩).succ) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)
      change Fin.cast _
        ((insertionSortEquiv r (b :: a :: (l1 ++ a2 :: l2))) ⟨l1.length + 2, byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)⊢ l1.length + 2 < (b :: a :: (l1 ++ a2 :: l2)).length simpAll goals completed! 🐙⟩) = _
      have hl : l1.length + 1 +1 = l1.length + 2 := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List α⊢ (insertionSortEquiv r (List.orderedInsert r a (b :: l1) ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (a :: b :: l1 ++ a2 :: l2)) ⟨(b :: l1).length + 1, ⋯⟩)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl✝:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)hl:l1.length + 1 + 1 = l1.length + 2⊢ Fin.cast ⋯ ((insertionSortEquiv r (b :: a :: (l1 ++ a2 :: l2))) ⟨l1.length + 2, ⋯⟩) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩) omeganegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl✝:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)hl:l1.length + 1 + 1 = l1.length + 2⊢ Fin.cast ⋯ ((insertionSortEquiv r (b :: a :: (l1 ++ a2 :: l2))) ⟨l1.length + 2, ⋯⟩) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl✝:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)hl:l1.length + 1 + 1 = l1.length + 2⊢ Fin.cast ⋯ ((insertionSortEquiv r (b :: a :: (l1 ++ a2 :: l2))) ⟨l1.length + 2, ⋯⟩) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 1 + 1, ⋯⟩)
      simp only [List.insertionSort, List.length_cons, hl]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl✝:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)hl:l1.length + 1 + 1 = l1.length + 2⊢ Fin.cast ⋯ ((insertionSortEquiv r (b :: a :: (l1 ++ a2 :: l2))) ⟨l1.length + 2, ⋯⟩) =
  Fin.cast ⋯ ((insertionSortEquiv r (a :: b :: (l1 ++ a2 :: l2))) ⟨l1.length + 2, ⋯⟩)
      conv_rhs =>
        erw [insertionSortEquiv_commute _ _ _ h _ _]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl✝:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)hl:l1.length + 1 + 1 = l1.length + 2| Fin.cast ⋯ ((finCongr ⋯) ((insertionSortEquiv r (b :: a :: (l1 ++ a2 :: l2))) ⟨l1.length + 2, ⋯⟩))
      simpnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αa2:αb:αl1:List αl2:List αh:¬r a bh1:List.orderedInsert r a (b :: l1) ++ a2 :: l2 = b :: List.orderedInsert r a l1 ++ a2 :: l2hl✝:List.insertionSort r (List.orderedInsert r a l1 ++ a2 :: l2) = List.insertionSort r (a :: l1 ++ a2 :: l2)hl:l1.length + 1 + 1 = l1.length + 2⊢ (insertionSortEquiv r (b :: a :: (l1 ++ a2 :: l2))) ⟨l1.length + 2, ⋯⟩ =
  (insertionSortEquiv r (b :: a :: (l1 ++ a2 :: l2))) ⟨l1.length + 2, ⋯⟩
      rflAll goals completed! 🐙

set_option backward.isDefEq.respectTransparency false in
lemma insertionSortEquiv_insertionSort_append {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (a : α) : (l1 l2 : List α) →
    (insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2) ⟨l1.length, byn:ℕα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ l1.length < (List.insertionSort r l1 ++ a :: l2).length simpAll goals completed! 🐙⟩)
    = finCongr (byn:ℕα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ (List.insertionSort r (l1 ++ a :: l2)).length = (List.insertionSort r (List.insertionSort r l1 ++ a :: l2)).length simpAll goals completed! 🐙) (insertionSortEquiv r (l1 ++ a :: l2) ⟨l1.length, byn:ℕα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ l1.length < (l1 ++ a :: l2).length simpAll goals completed! 🐙⟩)
  | [], l2 =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl2:List α⊢ (insertionSortEquiv r (List.insertionSort r [] ++ a :: l2)) ⟨[].length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r ([] ++ a :: l2)) ⟨[].length, ⋯⟩) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl2:List α⊢ (insertionSortEquiv r (List.insertionSort r [] ++ a :: l2)) ⟨[].length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r ([] ++ a :: l2)) ⟨[].length, ⋯⟩)
    apply insertionSortEquiv_congr_applyα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl2:List α⊢ List.insertionSort r [] ++ a :: l2 = [] ++ a :: l2
    simpAll goals completed! 🐙
  | b :: l1, l2 =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List α⊢ (insertionSortEquiv r (List.insertionSort r (b :: l1) ++ a :: l2)) ⟨(b :: l1).length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (b :: l1 ++ a :: l2)) ⟨(b :: l1).length, ⋯⟩) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List α⊢ (insertionSortEquiv r (List.insertionSort r (b :: l1) ++ a :: l2)) ⟨(b :: l1).length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (b :: l1 ++ a :: l2)) ⟨(b :: l1).length, ⋯⟩)
    simp only [List.insertionSort, List.length_cons, List.cons_append, finCongr_apply]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List α⊢ (insertionSortEquiv r (List.foldr (List.orderedInsert r) [] (b :: l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)
    have hl := insertionSortEquiv_orderedInsert_append r b a (List.insertionSort r l1) l2α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2))
    ⟨(List.insertionSort r l1).length + 1, ⋯⟩ =
  (finCongr ⋯)
    ((insertionSortEquiv r (b :: List.insertionSort r l1 ++ a :: l2)) ⟨(List.insertionSort r l1).length + 1, ⋯⟩)⊢ (insertionSortEquiv r (List.foldr (List.orderedInsert r) [] (b :: l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)
    simp only [List.length_insertionSort, List.cons_append, List.length_cons,
      finCongr_apply] at hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)⊢ (insertionSortEquiv r (List.foldr (List.orderedInsert r) [] (b :: l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)
    erw [hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)⊢ Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩) =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)⊢ Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩) =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)
    have ih := insertionSortEquiv_insertionSort_append r a l1 l2α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)ih:(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2)) ⟨l1.length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)⊢ Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩) =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)
    simp only [insertionSortEquiv, Nat.succ_eq_add_one, List.insertionSort, Equiv.trans_apply,
      equivCons_succ]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)ih:(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2)) ⟨l1.length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (List.foldr (List.orderedInsert r) [] l1 ++ a :: l2))
        b)
      ((insertionSortEquiv r (List.foldr (List.orderedInsert r) [] l1 ++ a :: l2)) ⟨l1.length, ⋯⟩).succ) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (l1 ++ a :: l2)) b)
      ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩).succ)
    erw [ihα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)ih:(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2)) ⟨l1.length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (List.foldr (List.orderedInsert r) [] l1 ++ a :: l2))
        b)
      ((finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)).succ) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (l1 ++ a :: l2)) b)
      ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩).succ)]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)ih:(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2)) ⟨l1.length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (List.foldr (List.orderedInsert r) [] l1 ++ a :: l2))
        b)
      ((finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)).succ) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (l1 ++ a :: l2)) b)
      ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩).succ)
    have hl : (List.insertionSort r (List.insertionSort r l1 ++ a :: l2)) =
        (List.insertionSort r (l1 ++ a :: l2)) := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List α⊢ (insertionSortEquiv r (List.insertionSort r (b :: l1) ++ a :: l2)) ⟨(b :: l1).length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (b :: l1 ++ a :: l2)) ⟨(b :: l1).length, ⋯⟩)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl✝:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)ih:(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2)) ⟨l1.length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)hl:List.insertionSort r (List.insertionSort r l1 ++ a :: l2) = List.insertionSort r (l1 ++ a :: l2)⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (List.foldr (List.orderedInsert r) [] l1 ++ a :: l2))
        b)
      ((finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)).succ) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (l1 ++ a :: l2)) b)
      ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩).succ)
      exact insertionSort_insertionSort_append r l1 (a :: l2)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl✝:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)ih:(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2)) ⟨l1.length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)hl:List.insertionSort r (List.insertionSort r l1 ++ a :: l2) = List.insertionSort r (l1 ++ a :: l2)⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (List.foldr (List.orderedInsert r) [] l1 ++ a :: l2))
        b)
      ((finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)).succ) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (l1 ++ a :: l2)) b)
      ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩).succ)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl✝:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)ih:(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2)) ⟨l1.length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)hl:List.insertionSort r (List.insertionSort r l1 ++ a :: l2) = List.insertionSort r (l1 ++ a :: l2)⊢ Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (List.foldr (List.orderedInsert r) [] l1 ++ a :: l2))
        b)
      ((finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)).succ) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (l1 ++ a :: l2)) b)
      ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩).succ)
    erw [orderedInsertEquiv_congr _ _ _ hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl✝:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)ih:(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2)) ⟨l1.length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)hl:List.insertionSort r (List.insertionSort r l1 ++ a :: l2) = List.insertionSort r (l1 ++ a :: l2)⊢ Fin.cast ⋯
    (((Fin.castOrderIso ⋯).trans
        ((orderedInsertEquiv r (List.insertionSort r (l1 ++ a :: l2)) b).trans (Fin.castOrderIso ⋯).toEquiv))
      ((finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)).succ) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (l1 ++ a :: l2)) b)
      ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩).succ)]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl✝:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)ih:(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2)) ⟨l1.length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)hl:List.insertionSort r (List.insertionSort r l1 ++ a :: l2) = List.insertionSort r (l1 ++ a :: l2)⊢ Fin.cast ⋯
    (((Fin.castOrderIso ⋯).trans
        ((orderedInsertEquiv r (List.insertionSort r (l1 ++ a :: l2)) b).trans (Fin.castOrderIso ⋯).toEquiv))
      ((finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)).succ) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (l1 ++ a :: l2)) b)
      ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩).succ)
    simp only [List.foldr_cons, finCongr_apply]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl1:List αl2:List αhl✝:(insertionSortEquiv r (List.orderedInsert r b (List.insertionSort r l1) ++ a :: l2)) ⟨l1.length + 1, ⋯⟩ =
  Fin.cast ⋯ ((insertionSortEquiv r (b :: (List.insertionSort r l1 ++ a :: l2))) ⟨l1.length + 1, ⋯⟩)ih:(insertionSortEquiv r (List.insertionSort r l1 ++ a :: l2)) ⟨l1.length, ⋯⟩ =
  (finCongr ⋯) ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)hl:List.insertionSort r (List.insertionSort r l1 ++ a :: l2) = List.insertionSort r (l1 ++ a :: l2)⊢ Fin.cast ⋯
    (((Fin.castOrderIso ⋯).trans
        ((orderedInsertEquiv r (List.insertionSort r (l1 ++ a :: l2)) b).trans (Fin.castOrderIso ⋯).toEquiv))
      (Fin.cast ⋯ ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩)).succ) =
  Fin.cast ⋯
    ((orderedInsertEquiv r (List.foldr (List.orderedInsert r) [] (l1 ++ a :: l2)) b)
      ((insertionSortEquiv r (l1 ++ a :: l2)) ⟨l1.length, ⋯⟩).succ)
    rflAll goals completed! 🐙

Insertion sort with equal fields

              

lemma orderedInsert_filter_of_pos {α : Type} (r : α → α → Prop) [DecidableRel r]
    [IsTrans α r] (a : α) (p : α → Prop) [DecidablePred p] (h : p a) : (l : List α) →
    (hl : l.Pairwise r) →
    List.filter p (List.orderedInsert r a l) = List.orderedInsert r a (List.filter p l)
  | [], hl =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ahl:List.Pairwise r []⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a []) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) []) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ahl:List.Pairwise r []⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a []) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) [])
    simp only [List.orderedInsert, List.filter_nil, List.orderedInsert_nil, List.filter_eq_self,
      List.mem_singleton, decide_eq_true_eq, forall_eq]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ahl:List.Pairwise r []⊢ p a
    exact hAll goals completed! 🐙
  | b :: l, hl =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a (b :: l)) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a (b :: l)) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))
    simp only [List.orderedInsert]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))
    by_cases hpb : p bposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p b⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p b⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)) <;>posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p b⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p b⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)) by_cases hab : r a bposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))
    ·posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:r a b⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)) simp only [hab, ↓reduceIte, hpb, decide_true, List.filter_cons_of_pos,
      List.orderedInsert.eq_2]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:r a b⊢ List.filter (fun b => decide (p b)) (a :: b :: l) = a :: b :: List.filter (fun b => decide (p b)) l
      rw [List.filter_cons_of_pos (byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:r a b⊢ decide (p a) = trueposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) (b :: l) = a :: b :: List.filter (fun b => decide (p b)) l simp [h]All goals completed! 🐙posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) (b :: l) = a :: b :: List.filter (fun b => decide (p b)) l)]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) (b :: l) = a :: b :: List.filter (fun b => decide (p b)) l
      rw [List.filter_cons_of_pos (byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:r a b⊢ decide (p b) = trueAll goals completed! 🐙 simp [hpb]All goals completed! 🐙All goals completed! 🐙)]All goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)) simp only [hab, ↓reduceIte]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))
      rw [List.filter_cons_of_pos (byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ decide (p b) = truenegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ b :: List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)) simp [hpb]All goals completed! 🐙negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ b :: List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)))]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ b :: List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))
      rw [List.filter_cons_of_pos (byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ decide (p b) = truenegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ b :: List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (b :: List.filter (fun b => decide (p b)) l) simp [hpb]All goals completed! 🐙negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ b :: List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (b :: List.filter (fun b => decide (p b)) l))]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ b :: List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (b :: List.filter (fun b => decide (p b)) l)
      simp only [List.orderedInsert, hab, ↓reduceIte, List.cons.injEq, true_and]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) l)
      simp only [List.pairwise_cons] at hlnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhpb:p bhab:¬r a bhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r l⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) l)
      exact orderedInsert_filter_of_pos r a p h l hl.2All goals completed! 🐙
    ·posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)) simp only [hab, ↓reduceIte]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ List.filter (fun b => decide (p b)) (a :: b :: l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))
      rw [List.filter_cons_of_pos (byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ decide (p a) = trueposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) l = List.orderedInsert r a (List.filter (fun b => decide (p b)) l) simp [h]All goals completed! 🐙posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) l = List.orderedInsert r a (List.filter (fun b => decide (p b)) l)),
        List.filter_cons_of_neg (byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ ¬decide (p b) = trueposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) l = List.orderedInsert r a (List.filter (fun b => decide (p b)) l) simp [hpb]All goals completed! 🐙posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) l = List.orderedInsert r a (List.filter (fun b => decide (p b)) l))]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) l = List.orderedInsert r a (List.filter (fun b => decide (p b)) l)
      rw [List.orderedInsert_eq_take_dropposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
      have hl : List.takeWhile (fun b => decide ¬r a b)
          (List.filter (fun b => decide (p b)) l) = [] := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a (b :: l)) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
        rw [List.takeWhile_eq_nil_iffα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ ∀ (hl : 0 < (List.filter (fun b => decide (p b)) l).length),
  ¬(decide ¬r a ((List.filter (fun b => decide (p b)) l).get ⟨0, hl⟩)) = trueα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ ∀ (hl : 0 < (List.filter (fun b => decide (p b)) l).length),
  ¬(decide ¬r a ((List.filter (fun b => decide (p b)) l).get ⟨0, hl⟩)) = trueposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a b⊢ ∀ (hl : 0 < (List.filter (fun b => decide (p b)) l).length),
  ¬(decide ¬r a ((List.filter (fun b => decide (p b)) l).get ⟨0, hl⟩)) = trueposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
        intro c hcα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a bc:0 < (List.filter (fun b => decide (p b)) l).lengthhc:(decide ¬r a ((List.filter (fun b => decide (p b)) l).get ⟨0, c⟩)) = true⊢ Falseposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
        simp only [List.get_eq_getElem, decide_not, Bool.not_eq_eq_eq_not, Bool.not_true,
          decide_eq_false_iff_not] at hcα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a bc:0 < (List.filter (fun b => decide (p b)) l).lengthhc:¬r a (List.filter (fun b => decide (p b)) l)[0]⊢ Falseposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
        apply hcα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a bc:0 < (List.filter (fun b => decide (p b)) l).lengthhc:¬r a (List.filter (fun b => decide (p b)) l)[0]⊢ r a (List.filter (fun b => decide (p b)) l)[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
        apply IsTrans.trans a b _ habα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:r a bc:0 < (List.filter (fun b => decide (p b)) l).lengthhc:¬r a (List.filter (fun b => decide (p b)) l)[0]⊢ r b (List.filter (fun b => decide (p b)) l)[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
        simp only [List.pairwise_cons] at hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhpb:¬p bhab:r a bc:0 < (List.filter (fun b => decide (p b)) l).lengthhc:¬r a (List.filter (fun b => decide (p b)) l)[0]hl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r l⊢ r b (List.filter (fun b => decide (p b)) l)[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
        exact hl.1 _ (List.mem_filter.mp (List.getElem_mem c)).1posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
    a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
      rw [hlposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  [] ++ a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  [] ++ a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ a :: List.filter (fun b => decide (p b)) l =
  [] ++ a :: List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
      simp only [decide_not, List.nil_append, List.cons.injEq, true_and]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ List.filter (fun b => decide (p b)) l =
  List.dropWhile (fun b => !decide (r a b)) (List.filter (fun b => decide (p b)) l)
      conv_lhs => rw [← List.takeWhile_append_dropWhile (p := fun b => decide ¬r a b)
        (l := List.filter (fun b => decide (p b)) l)]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []| List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) ++
  List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l)
      rw [hlposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ [] ++ List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) =
  List.dropWhile (fun b => !decide (r a b)) (List.filter (fun b => decide (p b)) l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ [] ++ List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) =
  List.dropWhile (fun b => !decide (r a b)) (List.filter (fun b => decide (p b)) l)]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl✝:List.Pairwise r (b :: l)hpb:¬p bhab:r a bhl:List.takeWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) = []⊢ [] ++ List.dropWhile (fun b => decide ¬r a b) (List.filter (fun b => decide (p b)) l) =
  List.dropWhile (fun b => !decide (r a b)) (List.filter (fun b => decide (p b)) l)
      simpAll goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (if r a b then a :: b :: l else b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)) simp only [hab, ↓reduceIte]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (b :: List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))
      rw [List.filter_cons_of_neg (byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ ¬decide (p b) = truenegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)) simp [hpb]All goals completed! 🐙negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l)))]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (b :: l))
      rw [List.filter_cons_of_neg (byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ ¬decide (p b) = truenegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) l) simp [hpb]All goals completed! 🐙negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) l))]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhl:List.Pairwise r (b :: l)hpb:¬p bhab:¬r a b⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) l)
      simp only [List.pairwise_cons] at hlnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:IsTrans α ra:αp:α → Propinst✝:DecidablePred ph:p ab:αl:List αhpb:¬p bhab:¬r a bhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r l⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) l)
      exact orderedInsert_filter_of_pos r a p h l hl.2All goals completed! 🐙

lemma orderedInsert_filter_of_neg {α : Type} (r : α → α → Prop) [DecidableRel r]
    (a : α) (p : α → Prop) [DecidablePred p] (h : ¬ p a) (l : List α) :
    List.filter p (List.orderedInsert r a l) = (List.filter p l) := byα:Typer:α → α → Propinst✝¹:DecidableRel ra:αp:α → Propinst✝:DecidablePred ph:¬p al:List α⊢ List.filter (fun b => decide (p b)) (List.orderedInsert r a l) = List.filter (fun b => decide (p b)) l
  rw [List.orderedInsert_eq_take_dropα:Typer:α → α → Propinst✝¹:DecidableRel ra:αp:α → Propinst✝:DecidablePred ph:¬p al:List α⊢ List.filter (fun b => decide (p b))
    (List.takeWhile (fun b => decide ¬r a b) l ++ a :: List.dropWhile (fun b => decide ¬r a b) l) =
  List.filter (fun b => decide (p b)) lα:Typer:α → α → Propinst✝¹:DecidableRel ra:αp:α → Propinst✝:DecidablePred ph:¬p al:List α⊢ List.filter (fun b => decide (p b))
    (List.takeWhile (fun b => decide ¬r a b) l ++ a :: List.dropWhile (fun b => decide ¬r a b) l) =
  List.filter (fun b => decide (p b)) l]α:Typer:α → α → Propinst✝¹:DecidableRel ra:αp:α → Propinst✝:DecidablePred ph:¬p al:List α⊢ List.filter (fun b => decide (p b))
    (List.takeWhile (fun b => decide ¬r a b) l ++ a :: List.dropWhile (fun b => decide ¬r a b) l) =
  List.filter (fun b => decide (p b)) l
  simp only [decide_not, List.filter_append]α:Typer:α → α → Propinst✝¹:DecidableRel ra:αp:α → Propinst✝:DecidablePred ph:¬p al:List α⊢ List.filter (fun b => decide (p b)) (List.takeWhile (fun b => !decide (r a b)) l) ++
    List.filter (fun b => decide (p b)) (a :: List.dropWhile (fun b => !decide (r a b)) l) =
  List.filter (fun b => decide (p b)) l
  rw [List.filter_cons_of_neg (byα:Typer:α → α → Propinst✝¹:DecidableRel ra:αp:α → Propinst✝:DecidablePred ph:¬p al:List α⊢ ¬decide (p a) = trueAll goals completed! 🐙 simp [h]All goals completed! 🐙All goals completed! 🐙), ← List.filter_append,α:Typer:α → α → Propinst✝¹:DecidableRel ra:αp:α → Propinst✝:DecidablePred ph:¬p al:List α⊢ List.filter (fun b => decide (p b))
    (List.takeWhile (fun b => !decide (r a b)) l ++ List.dropWhile (fun b => !decide (r a b)) l) =
  List.filter (fun b => decide (p b)) lAll goals completed! 🐙 List.takeWhile_append_dropWhileα:Typer:α → α → Propinst✝¹:DecidableRel ra:αp:α → Propinst✝:DecidablePred ph:¬p al:List α⊢ List.filter (fun b => decide (p b)) l = List.filter (fun b => decide (p b)) lAll goals completed! 🐙]All goals completed! 🐙

lemma insertionSort_filter {α : Type} (r : α → α → Prop) [DecidableRel r] [Std.Total r]
    [IsTrans α r] (p : α → Prop) [DecidablePred p] : (l : List α) →
    List.insertionSort r (List.filter p l) =
    List.filter p (List.insertionSort r l)
  | [] =>α:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred p⊢ List.insertionSort r (List.filter (fun b => decide (p b)) []) =
  List.filter (fun b => decide (p b)) (List.insertionSort r []) byα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred p⊢ List.insertionSort r (List.filter (fun b => decide (p b)) []) =
  List.filter (fun b => decide (p b)) (List.insertionSort r []) simpAll goals completed! 🐙
  | a :: l =>α:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List α⊢ List.insertionSort r (List.filter (fun b => decide (p b)) (a :: l)) =
  List.filter (fun b => decide (p b)) (List.insertionSort r (a :: l)) byα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List α⊢ List.insertionSort r (List.filter (fun b => decide (p b)) (a :: l)) =
  List.filter (fun b => decide (p b)) (List.insertionSort r (a :: l))
    simp only [List.insertionSort_cons]α:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List α⊢ List.insertionSort r (List.filter (fun b => decide (p b)) (a :: l)) =
  List.filter (fun b => decide (p b)) (List.orderedInsert r a (List.insertionSort r l))
    by_cases h : p aposα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:p a⊢ List.insertionSort r (List.filter (fun b => decide (p b)) (a :: l)) =
  List.filter (fun b => decide (p b)) (List.orderedInsert r a (List.insertionSort r l))negα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:¬p a⊢ List.insertionSort r (List.filter (fun b => decide (p b)) (a :: l)) =
  List.filter (fun b => decide (p b)) (List.orderedInsert r a (List.insertionSort r l))
    ·posα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:p a⊢ List.insertionSort r (List.filter (fun b => decide (p b)) (a :: l)) =
  List.filter (fun b => decide (p b)) (List.orderedInsert r a (List.insertionSort r l)) rw [orderedInsert_filter_of_pos r a p h _ (List.pairwise_insertionSort r l),posα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:p a⊢ List.insertionSort r (List.filter (fun b => decide (p b)) (a :: l)) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (List.insertionSort r l))posα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:p a⊢ List.insertionSort r (a :: List.filter (fun b => decide (p b)) l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (List.insertionSort r l))
        List.filter_cons_of_pos (byα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:p a⊢ decide (p a) = trueposα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:p a⊢ List.insertionSort r (a :: List.filter (fun b => decide (p b)) l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (List.insertionSort r l)) simpa using hAll goals completed! 🐙posα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:p a⊢ List.insertionSort r (a :: List.filter (fun b => decide (p b)) l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (List.insertionSort r l)))]posα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:p a⊢ List.insertionSort r (a :: List.filter (fun b => decide (p b)) l) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (List.insertionSort r l))
      simp only [List.insertionSort_cons]posα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:p a⊢ List.orderedInsert r a (List.insertionSort r (List.filter (fun b => decide (p b)) l)) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (List.insertionSort r l))
      rw [insertionSort_filterposα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:p a⊢ List.orderedInsert r a (List.filter (fun b => decide (p b)) (List.insertionSort r l)) =
  List.orderedInsert r a (List.filter (fun b => decide (p b)) (List.insertionSort r l))All goals completed! 🐙]All goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:¬p a⊢ List.insertionSort r (List.filter (fun b => decide (p b)) (a :: l)) =
  List.filter (fun b => decide (p b)) (List.orderedInsert r a (List.insertionSort r l)) rw [orderedInsert_filter_of_neg r a p h,negα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:¬p a⊢ List.insertionSort r (List.filter (fun b => decide (p b)) (a :: l)) =
  List.filter (fun b => decide (p b)) (List.insertionSort r l)All goals completed! 🐙 List.filter_cons_of_neg (byα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:¬p a⊢ ¬decide (p a) = trueAll goals completed! 🐙 simpa using hAll goals completed! 🐙All goals completed! 🐙),
        insertionSort_filternegα:Typer:α → α → Propinst✝³:DecidableRel rinst✝²:Std.Total rinst✝¹:IsTrans α rp:α → Propinst✝:DecidablePred pa:αl:List αh:¬p a⊢ List.filter (fun b => decide (p b)) (List.insertionSort r l) =
  List.filter (fun b => decide (p b)) (List.insertionSort r l)All goals completed! 🐙]All goals completed! 🐙lemma takeWhile_sorted_eq_filter {α : Type} (r : α → α → Prop) [DecidableRel r]
    [IsTrans α r] (a : α) : (l : List α) → (hl : l.Pairwise r) →
    List.takeWhile (fun c => ¬ r a c) l = List.filter (fun c => ¬ r a c) l
  | [], _ =>α:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αx✝:List.Pairwise r []⊢ List.takeWhile (fun c => decide ¬r a c) [] = List.filter (fun c => decide ¬r a c) [] byα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αx✝:List.Pairwise r []⊢ List.takeWhile (fun c => decide ¬r a c) [] = List.filter (fun c => decide ¬r a c) [] simpAll goals completed! 🐙
  | b :: l, hl =>α:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:List.Pairwise r (b :: l)⊢ List.takeWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide ¬r a c) (b :: l) byα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:List.Pairwise r (b :: l)⊢ List.takeWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide ¬r a c) (b :: l)
    simp only [List.pairwise_cons] at hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r l⊢ List.takeWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide ¬r a c) (b :: l)
    by_cases hb : ¬ r a bposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬r a b⊢ List.takeWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide ¬r a c) (b :: l)negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬¬r a b⊢ List.takeWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide ¬r a c) (b :: l)
    ·posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬r a b⊢ List.takeWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide ¬r a c) (b :: l) simp only [decide_not, hb, decide_false, Bool.not_false, List.takeWhile_cons_of_pos,
      List.filter_cons_of_pos, List.cons.injEq, true_and]posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬r a b⊢ List.takeWhile (fun c => !decide (r a c)) l = List.filter (fun c => !decide (r a c)) l
      simpa using takeWhile_sorted_eq_filter r a l hl.2All goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬¬r a b⊢ List.takeWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide ¬r a c) (b :: l) simp_all only [Decidable.not_not, decide_not, decide_true, Bool.not_true, Bool.false_eq_true,
      not_false_eq_true, List.takeWhile_cons_of_neg, List.filter_cons_of_neg, List.nil_eq,
      List.filter_eq_nil_iff, Bool.not_eq_eq_eq_not, decide_eq_false_iff_not]negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a b⊢ ∀ a_1 ∈ l, r a a_1
      exact fun c hc => IsTrans.trans a b c hb (hl.1 c hc)All goals completed! 🐙

lemma dropWhile_sorted_eq_filter {α : Type} (r : α → α → Prop) [DecidableRel r]
    [IsTrans α r] (a : α) : (l : List α) → (hl : l.Pairwise r) →
    List.dropWhile (fun c => ¬ r a c) l = List.filter (fun c => r a c) l
  | [], _ =>α:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αx✝:List.Pairwise r []⊢ List.dropWhile (fun c => decide ¬r a c) [] = List.filter (fun c => decide (r a c)) [] byα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αx✝:List.Pairwise r []⊢ List.dropWhile (fun c => decide ¬r a c) [] = List.filter (fun c => decide (r a c)) [] simpAll goals completed! 🐙
  | b :: l, hl =>α:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:List.Pairwise r (b :: l)⊢ List.dropWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide (r a c)) (b :: l) byα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:List.Pairwise r (b :: l)⊢ List.dropWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide (r a c)) (b :: l)
    simp only [List.pairwise_cons] at hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r l⊢ List.dropWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide (r a c)) (b :: l)
    by_cases hb : ¬ r a bposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬r a b⊢ List.dropWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide (r a c)) (b :: l)negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬¬r a b⊢ List.dropWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide (r a c)) (b :: l)
    ·posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬r a b⊢ List.dropWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide (r a c)) (b :: l) simp only [decide_not, hb, decide_false, Bool.not_false, List.dropWhile_cons_of_pos,
      Bool.false_eq_true, not_false_eq_true, List.filter_cons_of_neg]posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬r a b⊢ List.dropWhile (fun c => !decide (r a c)) l = List.filter (fun c => decide (r a c)) l
      simpa using dropWhile_sorted_eq_filter r a l hl.2All goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬¬r a b⊢ List.dropWhile (fun c => decide ¬r a c) (b :: l) = List.filter (fun c => decide (r a c)) (b :: l) simp_all only [Decidable.not_not, decide_not, decide_true, Bool.not_true, Bool.false_eq_true,
      not_false_eq_true, List.dropWhile_cons_of_neg, List.filter_cons_of_pos, List.cons.injEq,
      true_and]negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a b⊢ l = List.filter (fun c => decide (r a c)) l
      symmnegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a b⊢ List.filter (fun c => decide (r a c)) l = l
      rw [List.filter_eq_selfnegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a b⊢ ∀ a_1 ∈ l, decide (r a a_1) = truenegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a b⊢ ∀ a_1 ∈ l, decide (r a a_1) = true]negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a b⊢ ∀ a_1 ∈ l, decide (r a a_1) = true
      intro c hcnegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bc:αhc:c ∈ l⊢ decide (r a c) = true
      simpa using IsTrans.trans a b c hb (hl.1 c hc)All goals completed! 🐙

lemma dropWhile_sorted_eq_filter_filter {α : Type} (r : α → α → Prop) [DecidableRel r]
    [IsTrans α r] (a : α) :(l : List α) → (hl : l.Pairwise r) →
    List.filter (fun c => r a c) l =
    List.filter (fun c => r a c ∧ r c a) l ++ List.filter (fun c => r a c ∧ ¬ r c a) l
  | [], _ =>α:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αx✝:List.Pairwise r []⊢ List.filter (fun c => decide (r a c)) [] =
  List.filter (fun c => decide (r a c ∧ r c a)) [] ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) [] byα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αx✝:List.Pairwise r []⊢ List.filter (fun c => decide (r a c)) [] =
  List.filter (fun c => decide (r a c ∧ r c a)) [] ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) []
    simpAll goals completed! 🐙
  | b :: l, hl =>α:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:List.Pairwise r (b :: l)⊢ List.filter (fun c => decide (r a c)) (b :: l) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) (b :: l) byα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:List.Pairwise r (b :: l)⊢ List.filter (fun c => decide (r a c)) (b :: l) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) (b :: l)
    simp only [List.pairwise_cons] at hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r l⊢ List.filter (fun c => decide (r a c)) (b :: l) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) (b :: l)
    by_cases hb : ¬ r a bposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬r a b⊢ List.filter (fun c => decide (r a c)) (b :: l) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) (b :: l)negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬¬r a b⊢ List.filter (fun c => decide (r a c)) (b :: l) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) (b :: l)
    ·posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬r a b⊢ List.filter (fun c => decide (r a c)) (b :: l) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) (b :: l) simp only [hb, decide_false, Bool.false_eq_true, not_false_eq_true, List.filter_cons_of_neg,
      Bool.decide_and, Bool.false_and, decide_not]posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬r a b⊢ List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) l
      simpa using dropWhile_sorted_eq_filter_filter r a l hl.2All goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:¬¬r a b⊢ List.filter (fun c => decide (r a c)) (b :: l) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) (b :: l) simp_all only [Decidable.not_not, decide_true, List.filter_cons_of_pos, Bool.decide_and,
      decide_not]negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a b⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l) ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)
      by_cases hba : r b aposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l) ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b a⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l) ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)
      ·posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l) ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l) simp only [hba, decide_true, Bool.not_true, Bool.and_false, Bool.false_eq_true,
        not_false_eq_true, List.filter_cons_of_neg]posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l) ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) l
        rw [List.filter_cons_of_pos,posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ b :: List.filter (fun c => decide (r a c)) l =
  b :: List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) lposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ (decide (r a b) && decide (r b a)) = trueposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ b :: (List.filter (fun c => decide (r a c ∧ r c a)) l ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) l) =
  b :: List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) lpos.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ List.Pairwise r lposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ (decide (r a b) && decide (r b a)) = true dropWhile_sorted_eq_filter_filterposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ b :: (List.filter (fun c => decide (r a c ∧ r c a)) l ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) l) =
  b :: List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) lpos.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ List.Pairwise r lposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ (decide (r a b) && decide (r b a)) = trueposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ b :: (List.filter (fun c => decide (r a c ∧ r c a)) l ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) l) =
  b :: List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) lpos.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ List.Pairwise r lposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ (decide (r a b) && decide (r b a)) = true]posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ b :: (List.filter (fun c => decide (r a c ∧ r c a)) l ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) l) =
  b :: List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) lpos.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ List.Pairwise r lposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ (decide (r a b) && decide (r b a)) = true
        simp only [Bool.decide_and, decide_not, List.cons_append]pos.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ List.Pairwise r lposα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ (decide (r a b) && decide (r b a)) = true
        exact hl.2posα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:r b a⊢ (decide (r a b) && decide (r b a)) = true
        simp_allAll goals completed! 🐙
      ·negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b a⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l) ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l) simp only [hba, decide_false, Bool.and_false, Bool.false_eq_true, not_false_eq_true,
        List.filter_cons_of_neg]negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b a⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)
        have h1 : List.filter (fun c => decide (r a c) && decide (r c a)) l = [] := byα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:List.Pairwise r (b :: l)⊢ List.filter (fun c => decide (r a c)) (b :: l) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) (b :: l)negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)
          rw [@List.filter_eq_nil_iffα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b a⊢ ∀ a_1 ∈ l, ¬(decide (r a a_1) && decide (r a_1 a)) = trueα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b a⊢ ∀ a_1 ∈ l, ¬(decide (r a a_1) && decide (r a_1 a)) = truenegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)]α:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b a⊢ ∀ a_1 ∈ l, ¬(decide (r a a_1) && decide (r a_1 a)) = truenegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)
          intro c hcα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ac:αhc:c ∈ l⊢ ¬(decide (r a c) && decide (r c a)) = truenegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)
          simp only [Bool.and_eq_true, decide_eq_true_eq, not_and]α:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ac:αhc:c ∈ l⊢ r a c → ¬r c anegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)
          intro hac hcaα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ac:αhc:c ∈ lhac:r a chca:r c a⊢ Falsenegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)
          exact hba (IsTrans.trans b c a (hl.1 c hc) hca)negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c)) l =
  List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)
        rw [h1,negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c)) l = [] ++ List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: (List.filter (fun c => decide (r a c ∧ r c a)) l ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) l) =
  [] ++ List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)neg.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ List.Pairwise r l dropWhile_sorted_eq_filter_filternegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: (List.filter (fun c => decide (r a c ∧ r c a)) l ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) l) =
  [] ++ List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)neg.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ List.Pairwise r lnegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: (List.filter (fun c => decide (r a c ∧ r c a)) l ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) l) =
  [] ++ List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)neg.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ List.Pairwise r l]negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: (List.filter (fun c => decide (r a c ∧ r c a)) l ++ List.filter (fun c => decide (r a c ∧ ¬r c a)) l) =
  [] ++ List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)neg.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ List.Pairwise r l
        simp only [Bool.decide_and, h1, decide_not, List.nil_append]negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c) && !decide (r c a)) l =
  List.filter (fun c => decide (r a c) && !decide (r c a)) (b :: l)neg.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ List.Pairwise r l
        rw [List.filter_cons_of_posnegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ b :: List.filter (fun c => decide (r a c) && !decide (r c a)) l =
  b :: List.filter (fun c => decide (r a c) && !decide (r c a)) lnegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ (decide (r a b) && !decide (r b a)) = trueneg.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ List.Pairwise r lnegα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ (decide (r a b) && !decide (r b a)) = trueneg.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ List.Pairwise r l]negα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ (decide (r a b) && !decide (r b a)) = trueneg.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ List.Pairwise r l
        simp_all only [List.filter_eq_nil_iff, Bool.and_eq_true, decide_eq_true_eq, not_and,
          decide_true, decide_false, Bool.not_false, Bool.and_self]neg.hlα:Typer:α → α → Propinst✝¹:DecidableRel rinst✝:IsTrans α ra:αb:αl:List αhl:(∀ a' ∈ l, r b a') ∧ List.Pairwise r lhb:r a bhba:¬r b ah1:List.filter (fun c => decide (r a c) && decide (r c a)) l = []⊢ List.Pairwise r l
        exact hl.2All goals completed! 🐙

lemma filter_rel_eq_insertionSort {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (a : α) : (l : List α) →
    List.filter (fun c => r a c ∧ r c a) (l.insertionSort r) =
    List.filter (fun c => r a c ∧ r c a) l
  | [] =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:α⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.insertionSort r []) =
  List.filter (fun c => decide (r a c ∧ r c a)) [] byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:α⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.insertionSort r []) =
  List.filter (fun c => decide (r a c ∧ r c a)) [] simpAll goals completed! 🐙
  | b :: l =>α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List α⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.insertionSort r (b :: l)) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List α⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.insertionSort r (b :: l)) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l)
    simp only [List.insertionSort_cons]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List α⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l)
    by_cases h : r a b ∧ r b aposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b a⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l)
    ·posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b a⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) have hl := orderedInsert_filter_of_pos r b (fun c => r a c ∧ r c a) h
        (List.insertionSort r l) (List.pairwise_insertionSort r l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b ∧ r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b ∧ r b a)) (List.insertionSort r l))⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l)
      simp only [Bool.decide_and] at hl ⊢posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))⊢ List.filter (fun c => decide (r a c) && decide (r c a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
      rw [hlposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))⊢ List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))⊢ List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))⊢ List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
      rw [List.orderedInsert_eq_take_dropposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
      have ht : List.takeWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a))
          (List.insertionSort r l)) = [] := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List α⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.insertionSort r (b :: l)) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
        rw [List.takeWhile_eq_nil_iffα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))⊢ ∀ (hl : 0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).length),
  ¬(decide ¬r b ((List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).get ⟨0, hl⟩)) = trueα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))⊢ ∀ (hl : 0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).length),
  ¬(decide ¬r b ((List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).get ⟨0, hl⟩)) = trueposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))⊢ ∀ (hl : 0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).length),
  ¬(decide ¬r b ((List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).get ⟨0, hl⟩)) = trueposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
        intro hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl✝:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))hl:0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).length⊢ ¬(decide ¬r b ((List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).get ⟨0, hl⟩)) = trueposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
        simp only [List.get_eq_getElem, decide_not, Bool.not_eq_eq_eq_not, Bool.not_true,
          decide_eq_false_iff_not, Decidable.not_not]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl✝:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))hl:0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).length⊢ r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
        have hx := List.getElem_mem hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl✝:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))hl:0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).lengthhx:(List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] ∈
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
        simp only [List.mem_filter, List.mem_insertionSort, Bool.and_eq_true,
          decide_eq_true_eq] at hxα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl✝:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))hl:0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).lengthhx:(List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] ∈ l ∧
  r a (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] ∧
    r (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] a⊢ r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
        apply IsTrans.trans b a _ h.2α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl✝:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))hl:0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).lengthhx:(List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] ∈ l ∧
  r a (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] ∧
    r (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] a⊢ r a (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
        simp_allposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
      rw [htposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ [] ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ [] ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ [] ++
    b ::
      List.dropWhile (fun b_1 => decide ¬r b b_1)
        (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
      simp only [decide_not, List.nil_append]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ b ::
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (b :: l)
      rw [List.filter_cons_of_posposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ b ::
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  b :: List.filter (fun b => decide (r a b) && decide (r b a)) lposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = trueposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ b ::
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  b :: List.filter (fun b => decide (r a b) && decide (r b a)) lposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ b ::
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  b :: List.filter (fun b => decide (r a b) && decide (r b a)) lposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      simp only [List.cons.injEq, true_and]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ List.dropWhile (fun b_1 => !decide (r b b_1))
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) lposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      have ih := filter_rel_eq_insertionSort r a lposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c ∧ r c a)) (List.insertionSort r l) = List.filter (fun c => decide (r a c ∧ r c a)) l⊢ List.dropWhile (fun b_1 => !decide (r b b_1))
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) lposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      simp only [Bool.decide_and] at ihposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l⊢ List.dropWhile (fun b_1 => !decide (r b b_1))
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) lposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      rw [← ihposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l⊢ List.dropWhile (fun b_1 => !decide (r b b_1))
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = trueposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l⊢ List.dropWhile (fun b_1 => !decide (r b b_1))
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l⊢ List.dropWhile (fun b_1 => !decide (r b b_1))
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      have htd := List.takeWhile_append_dropWhile (p := fun b_1 => decide ¬r b b_1)
        (l := List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lhtd:List.takeWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    List.dropWhile (fun b_1 => decide ¬r b b_1)
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ List.dropWhile (fun b_1 => !decide (r b b_1))
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      simp only [decide_not] at htdposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lhtd:List.takeWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ List.dropWhile (fun b_1 => !decide (r b b_1))
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l)posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      conv_rhs => rw [← htd]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lhtd:List.takeWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)| List.takeWhile (fun b_1 => !decide (r b b_1))
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
  List.dropWhile (fun b_1 => !decide (r b b_1))
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))
      simp only [List.self_eq_append_left, List.takeWhile_eq_nil_iff, List.get_eq_getElem,
        Bool.not_eq_eq_eq_not, Bool.not_true, decide_eq_false_iff_not, Decidable.not_not]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lhtd:List.takeWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ ∀ (hl : 0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).length),
  r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      intro hlposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl✝:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lhtd:List.takeWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)hl:0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).length⊢ r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      have hx := List.getElem_mem hlposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl✝:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lhtd:List.takeWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)hl:0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).lengthhx:(List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] ∈
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      simp only [List.mem_filter, List.mem_insertionSort, Bool.and_eq_true, decide_eq_true_eq] at hxposα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl✝:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lhtd:List.takeWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)hl:0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).lengthhx:(List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] ∈ l ∧
  r a (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] ∧
    r (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] a⊢ r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      apply IsTrans.trans b a _ h.2posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl✝:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []ih:List.filter (fun c => decide (r a c) && decide (r c a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lhtd:List.takeWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) ++
    List.dropWhile (fun b_1 => !decide (r b b_1))
      (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)hl:0 < (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)).lengthhx:(List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] ∈ l ∧
  r a (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] ∧
    r (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0] a⊢ r a (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))[0]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      simp_all only [decide_not, List.takeWhile_eq_nil_iff, List.get_eq_getElem,
        Bool.not_eq_eq_eq_not, Bool.not_true, decide_eq_false_iff_not, Decidable.not_not,
        List.takeWhile_append_dropWhile]posα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:r a b ∧ r b ahl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.orderedInsert r b (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l))ht:List.takeWhile (fun b_1 => decide ¬r b b_1)
    (List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)) =
  []⊢ (decide (r a b) && decide (r b a)) = true
      simp_allAll goals completed! 🐙
    ·negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l) have hl := orderedInsert_filter_of_neg r b (fun c => r a c ∧ r c a) h (List.insertionSort r l)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b ∧ r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b ∧ r b a)) (List.insertionSort r l)⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c ∧ r c a)) (b :: l)
      simp only [Bool.decide_and] at hl ⊢negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ List.filter (fun c => decide (r a c) && decide (r c a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
      rw [hlnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) (b :: l)
      rw [List.filter_cons_of_negnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ ¬(decide (r a b) && decide (r b a)) = truenegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ ¬(decide (r a b) && decide (r b a)) = true]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ ¬(decide (r a b) && decide (r b a)) = true
      have ih := filter_rel_eq_insertionSort r a lnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)ih:List.filter (fun c => decide (r a c ∧ r c a)) (List.insertionSort r l) = List.filter (fun c => decide (r a c ∧ r c a)) l⊢ List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l) =
  List.filter (fun c => decide (r a c) && decide (r c a)) lnegα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ ¬(decide (r a b) && decide (r b a)) = true
      simp_all only [not_and, Bool.decide_and]negα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αb:αl:List αh:¬(r a b ∧ r b a)hl:List.filter (fun b => decide (r a b) && decide (r b a)) (List.orderedInsert r b (List.insertionSort r l)) =
  List.filter (fun b => decide (r a b) && decide (r b a)) (List.insertionSort r l)⊢ ¬(decide (r a b) && decide (r b a)) = true
      simpa using hAll goals completed! 🐙

lemma insertionSort_of_eq_list {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (a : α) (l1 l l2 : List α)
    (h : ∀ b ∈ l, r a b ∧ r b a) :
    List.insertionSort r (l1 ++ l ++ l2) =
    (List.takeWhile (fun c => ¬ r a c) ((l1 ++ l2).insertionSort r))
    ++ (List.filter (fun c => r a c ∧ r c a) l1)
    ++ l
    ++ (List.filter (fun c => r a c ∧ r c a) l2)
    ++ (List.filter (fun c => r a c ∧ ¬ r c a) ((l1 ++ l2).insertionSort r)) := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))
  have hlt : List.takeWhile (fun c => ¬ r a c) ((l1 ++ l ++ l2).insertionSort r)
      = List.takeWhile (fun c => ¬ r a c) ((l1 ++ l2).insertionSort r) := by
    rw [takeWhile_sorted_eq_filter,α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.filter (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.filter (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.filter (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2)) takeWhile_sorted_eq_filterα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.filter (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.filter (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.filter (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.filter (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.filter (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.filter (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))
    rw [← insertionSort_filter,α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.insertionSort r (List.filter (fun b => decide ¬r a b) (l1 ++ l ++ l2)) =
  List.filter (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.insertionSort r (List.filter (fun b => decide ¬r a b) (l1 ++ l ++ l2)) =
  List.insertionSort r (List.filter (fun b => decide ¬r a b) (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2)) ← insertionSort_filterα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.insertionSort r (List.filter (fun b => decide ¬r a b) (l1 ++ l ++ l2)) =
  List.insertionSort r (List.filter (fun b => decide ¬r a b) (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.insertionSort r (List.filter (fun b => decide ¬r a b) (l1 ++ l ++ l2)) =
  List.insertionSort r (List.filter (fun b => decide ¬r a b) (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.insertionSort r (List.filter (fun b => decide ¬r a b) (l1 ++ l ++ l2)) =
  List.insertionSort r (List.filter (fun b => decide ¬r a b) (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))
    congr 1e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.filter (fun b => decide ¬r a b) (l1 ++ l ++ l2) = List.filter (fun b => decide ¬r a b) (l1 ++ l2)hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))
    simp only [decide_not, List.append_assoc, List.filter_append, List.append_cancel_left_eq,
      List.append_left_eq_self, List.filter_eq_nil_iff, Bool.not_eq_eq_eq_not, Bool.not_true,
      decide_eq_false_iff_not, Decidable.not_not]e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ ∀ a_1 ∈ l, r a a_1hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))
    exact fun b hb => (h b hb).1hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))
    exact List.pairwise_insertionSort r (l1 ++ l2)hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.Pairwise r (List.insertionSort r (l1 ++ l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))
    exact List.pairwise_insertionSort r (l1 ++ l ++ l2)α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))
  conv_lhs => rw [← List.takeWhile_append_dropWhile (p := fun c => decide ¬ r a c)
    (l := (l1 ++ l ++ l2).insertionSort r), hlt]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))| List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
  List.dropWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2))
  simp only [decide_not, Bool.decide_and, List.append_assoc, List.append_cancel_left_eq]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))⊢ List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l1 ++
    (l ++
      (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
        List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))))
  have h1 := dropWhile_sorted_eq_filter r a (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l1 ++
    (l ++
      (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
        List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))))
  simp only [decide_not] at h1α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l1 ++
    (l ++
      (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
        List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))))
  rw [h1,α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l1 ++
    (l ++
      (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
        List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c ∧ r c a)) (l1 ++ (l ++ l2)) ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l1 ++
    (l ++
      (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
        List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) dropWhile_sorted_eq_filter_filter,α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c ∧ r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l1 ++
    (l ++
      (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
        List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c ∧ r c a)) (l1 ++ (l ++ l2)) ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l1 ++
    (l ++
      (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
        List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) filter_rel_eq_insertionSortα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c ∧ r c a)) (l1 ++ (l ++ l2)) ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l1 ++
    (l ++
      (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
        List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c ∧ r c a)) (l1 ++ (l ++ l2)) ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l1 ++
    (l ++
      (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
        List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c ∧ r c a)) (l1 ++ (l ++ l2)) ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l1 ++
    (l ++
      (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
        List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  simp only [Bool.decide_and, List.filter_append, decide_not, List.append_assoc,
    List.append_cancel_left_eq]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c) && decide (r c a)) l ++
    (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
      List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ (l ++ l2)))) =
  l ++
    (List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
      List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2)))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  congr 1e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c) && decide (r c a)) l = le_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  simp only [List.filter_eq_self, Bool.and_eq_true, decide_eq_true_eq]e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ ∀ b ∈ l, r a b ∧ r b ae_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  exact he_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && decide (r c a)) l2 ++
    List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  congr 1e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  have h1 := insertionSort_filter r (fun c => decide (r a c) && !decide (r c a)) (l1 ++ (l ++ l2))e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r (List.filter (fun b => decide ((decide (r a b) && !decide (r b a)) = true)) (l1 ++ (l ++ l2))) =
  List.filter (fun b => decide ((decide (r a b) && !decide (r b a)) = true)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  simp only [Bool.and_eq_true, decide_eq_true_eq, Bool.not_eq_eq_eq_not, Bool.not_true,
    decide_eq_false_iff_not, Bool.decide_and, decide_not, List.filter_append] at h1e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ (l ++ l2))) =
  List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  rw [← h1e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))]e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  have h2 := insertionSort_filter r (fun c => decide (r a c) && !decide (r c a)) (l1 ++ l2)e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r (List.filter (fun b => decide ((decide (r a b) && !decide (r b a)) = true)) (l1 ++ l2)) =
  List.filter (fun b => decide ((decide (r a b) && !decide (r b a)) = true)) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  simp only [Bool.and_eq_true, decide_eq_true_eq, Bool.not_eq_eq_eq_not, Bool.not_true,
    decide_eq_false_iff_not, Bool.decide_and, decide_not, List.filter_append] at h2e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun c => decide (r a c) && !decide (r c a)) (List.insertionSort r (l1 ++ l2))hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  rw [← h2e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2)hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2)hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))]e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))⊢ List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2)hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  congre_a.e_a.e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))⊢ List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
    List.filter (fun b => decide (r a b) && !decide (r b a)) l2 =
  List.filter (fun b => decide (r a b) && !decide (r b a)) l2hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  have hl : List.filter (fun b => decide (r a b) && !decide (r b a)) l = [] := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b a⊢ List.insertionSort r (l1 ++ l ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
          List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
        l ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))e_a.e_a.e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))hl:List.filter (fun b => decide (r a b) && !decide (r b a)) l = []⊢ List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
    List.filter (fun b => decide (r a b) && !decide (r b a)) l2 =
  List.filter (fun b => decide (r a b) && !decide (r b a)) l2hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
    rw [@List.filter_eq_nil_iffα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))⊢ ∀ a_1 ∈ l, ¬(decide (r a a_1) && !decide (r a_1 a)) = trueα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))⊢ ∀ a_1 ∈ l, ¬(decide (r a a_1) && !decide (r a_1 a)) = truee_a.e_a.e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))hl:List.filter (fun b => decide (r a b) && !decide (r b a)) l = []⊢ List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
    List.filter (fun b => decide (r a b) && !decide (r b a)) l2 =
  List.filter (fun b => decide (r a b) && !decide (r b a)) l2hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))⊢ ∀ a_1 ∈ l, ¬(decide (r a a_1) && !decide (r a_1 a)) = truee_a.e_a.e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))hl:List.filter (fun b => decide (r a b) && !decide (r b a)) l = []⊢ List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
    List.filter (fun b => decide (r a b) && !decide (r b a)) l2 =
  List.filter (fun b => decide (r a b) && !decide (r b a)) l2hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
    intro c hcα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))c:αhc:c ∈ l⊢ ¬(decide (r a c) && !decide (r c a)) = truee_a.e_a.e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))hl:List.filter (fun b => decide (r a b) && !decide (r b a)) l = []⊢ List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
    List.filter (fun b => decide (r a b) && !decide (r b a)) l2 =
  List.filter (fun b => decide (r a b) && !decide (r b a)) l2hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
    simp_alle_a.e_a.e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))hl:List.filter (fun b => decide (r a b) && !decide (r b a)) l = []⊢ List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
    List.filter (fun b => decide (r a b) && !decide (r b a)) l2 =
  List.filter (fun b => decide (r a b) && !decide (r b a)) l2hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))e_a.e_a.e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))hl:List.filter (fun b => decide (r a b) && !decide (r b a)) l = []⊢ List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
    List.filter (fun b => decide (r a b) && !decide (r b a)) l2 =
  List.filter (fun b => decide (r a b) && !decide (r b a)) l2hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  rw [hle_a.e_a.e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))hl:List.filter (fun b => decide (r a b) && !decide (r b a)) l = []⊢ [] ++ List.filter (fun b => decide (r a b) && !decide (r b a)) l2 =
  List.filter (fun b => decide (r a b) && !decide (r b a)) l2hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))e_a.e_a.e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))hl:List.filter (fun b => decide (r a b) && !decide (r b a)) l = []⊢ [] ++ List.filter (fun b => decide (r a b) && !decide (r b a)) l2 =
  List.filter (fun b => decide (r a b) && !decide (r b a)) l2hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))]e_a.e_a.e_a.e_aα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1✝:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))h1:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      (List.filter (fun b => decide (r a b) && !decide (r b a)) l ++
        List.filter (fun b => decide (r a b) && !decide (r b a)) l2)) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ (l ++ l2)))h2:List.insertionSort r
    (List.filter (fun b => decide (r a b) && !decide (r b a)) l1 ++
      List.filter (fun b => decide (r a b) && !decide (r b a)) l2) =
  List.filter (fun b => decide (r a b) && !decide (r b a)) (List.insertionSort r (l1 ++ l2))hl:List.filter (fun b => decide (r a b) && !decide (r b a)) l = []⊢ [] ++ List.filter (fun b => decide (r a b) && !decide (r b a)) l2 =
  List.filter (fun b => decide (r a b) && !decide (r b a)) l2hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  simp only [List.nil_append]hlα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  exact List.pairwise_insertionSort r (l1 ++ (l ++ l2))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl:List αl2:List αh:∀ b ∈ l, r a b ∧ r b ahlt:List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l ++ l2)) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2))h1:List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2))) →
  List.dropWhile (fun c => !decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2))) =
    List.filter (fun c => decide (r a c)) (List.insertionSort r (l1 ++ (l ++ l2)))⊢ List.Pairwise r (List.insertionSort r (l1 ++ (l ++ l2)))
  exact List.pairwise_insertionSort r (l1 ++ (l ++ l2))All goals completed! 🐙lemma insertionSort_of_takeWhile_filter {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (a : α) (l1 l2 : List α) :
    List.insertionSort r (l1 ++ l2) =
    (List.takeWhile (fun c => ¬ r a c) ((l1 ++ l2).insertionSort r))
    ++ (List.filter (fun c => r a c ∧ r c a) l1)
    ++ (List.filter (fun c => r a c ∧ r c a) l2)
    ++ (List.filter (fun c => r a c ∧ ¬ r c a) ((l1 ++ l2).insertionSort r)) := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ List.insertionSort r (l1 ++ l2) =
  List.takeWhile (fun c => decide ¬r a c) (List.insertionSort r (l1 ++ l2)) ++
        List.filter (fun c => decide (r a c ∧ r c a)) l1 ++
      List.filter (fun c => decide (r a c ∧ r c a)) l2 ++
    List.filter (fun c => decide (r a c ∧ ¬r c a)) (List.insertionSort r (l1 ++ l2))
  simpa using insertionSort_of_eq_list r a l1 [] l2 (byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ra:αl1:List αl2:List α⊢ ∀ b ∈ [], r a b ∧ r b a simpAll goals completed! 🐙)