Physlib.Mathematics.List

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.Fin
public import Mathlib.Order.Lattice.Nat
public import Mathlib.Data.List.TakeWhile
import all Mathlib.Data.List.Sort

List lemmas

              

lemma takeWhile_eraseIdx {I : Type} (P : I → Prop) [DecidablePred P] :
    (l : List I) → (i : ℕ) → (hi : ∀ (i j : Fin l.length), i < j → P (l.get j) → P (l.get i)) →
    List.takeWhile P (List.eraseIdx l i) = (List.takeWhile P l).eraseIdx i
  | [], _, h =>I:TypeP:I → Propinst✝:DecidablePred Px✝:ℕh:∀ (i j : Fin [].length), i < j → P ([].get j) → P ([].get i)⊢ List.takeWhile (fun b => decide (P b)) ([].eraseIdx x✝) = (List.takeWhile (fun b => decide (P b)) []).eraseIdx x✝ byI:TypeP:I → Propinst✝:DecidablePred Px✝:ℕh:∀ (i j : Fin [].length), i < j → P ([].get j) → P ([].get i)⊢ List.takeWhile (fun b => decide (P b)) ([].eraseIdx x✝) = (List.takeWhile (fun b => decide (P b)) []).eraseIdx x✝
    rflAll goals completed! 🐙
  | a :: [], 0, h =>I:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ List.takeWhile (fun b => decide (P b)) ([a].eraseIdx 0) = (List.takeWhile (fun b => decide (P b)) [a]).eraseIdx 0 byI:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ List.takeWhile (fun b => decide (P b)) ([a].eraseIdx 0) = (List.takeWhile (fun b => decide (P b)) [a]).eraseIdx 0
    simp only [List.takeWhile, List.eraseIdx_zero]I:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ List.takeWhile (fun b => decide (P b)) [a].tail =
  (match decide (P a) with
    | true => [a]
    | false => []).tail
    splith_1I:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)x✝:Boolheq✝:decide (P a) = true⊢ List.takeWhile (fun b => decide (P b)) [a].tail = [a].tailh_2I:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)x✝:Boolheq✝:decide (P a) = false⊢ List.takeWhile (fun b => decide (P b)) [a].tail = [].tail <;>h_1I:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)x✝:Boolheq✝:decide (P a) = true⊢ List.takeWhile (fun b => decide (P b)) [a].tail = [a].tailh_2I:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)x✝:Boolheq✝:decide (P a) = false⊢ List.takeWhile (fun b => decide (P b)) [a].tail = [].tail rflAll goals completed! 🐙
  | a :: [], Nat.succ n, h =>I:TypeP:I → Propinst✝:DecidablePred Pa:In:ℕh:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ List.takeWhile (fun b => decide (P b)) ([a].eraseIdx n.succ) =
  (List.takeWhile (fun b => decide (P b)) [a]).eraseIdx n.succ byI:TypeP:I → Propinst✝:DecidablePred Pa:In:ℕh:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ List.takeWhile (fun b => decide (P b)) ([a].eraseIdx n.succ) =
  (List.takeWhile (fun b => decide (P b)) [a]).eraseIdx n.succ
    simp only [Nat.succ_eq_add_one, List.eraseIdx_cons_succ, List.eraseIdx_nil]I:TypeP:I → Propinst✝:DecidablePred Pa:In:ℕh:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ List.takeWhile (fun b => decide (P b)) [a] = (List.takeWhile (fun b => decide (P b)) [a]).eraseIdx (n + 1)
    rw [List.eraseIdx_of_length_le ((List.takeWhile_sublist _).length_le.trans (byI:TypeP:I → Propinst✝:DecidablePred Pa:In:ℕh:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ [a].length ≤ n + 1All goals completed! 🐙 simpAll goals completed! 🐙All goals completed! 🐙))]All goals completed! 🐙
  | a :: b :: l, 0, h =>I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.takeWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx 0 byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.takeWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx 0
    simp only [List.takeWhile, List.eraseIdx_zero]I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail
    by_cases hPb : P bposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tailnegI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P b⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail
    ·posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail have hPa : P a := byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.takeWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx 0posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail
        simpa using h ⟨0, byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ 0 < (a :: b :: l).lengthposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail simpAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail⟩ ⟨1, byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ 1 < (a :: b :: l).lengthposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail simpAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail⟩ (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ ⟨0, ⋯⟩ < ⟨1, ⋯⟩posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail simpAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail) (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ P ((a :: b :: l).get ⟨1, ⋯⟩)posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail simpa using hPbAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail)posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail
      simp [hPb, hPa]All goals completed! 🐙
    ·negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P b⊢ List.takeWhile (fun b => decide (P b)) (a :: b :: l).tail =
  (match decide (P a) with
    | true =>
      a ::
        match decide (P b) with
        | true => b :: List.takeWhile (fun b => decide (P b)) l
        | false => []
    | false => []).tail simp [hPb]negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P b⊢ (match decide (P a) with
    | true => [a]
    | false => []).tail =
  []
      splith_1I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bx✝:Boolheq✝:decide (P a) = true⊢ [a].tail = []h_2I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bx✝:Boolheq✝:decide (P a) = false⊢ [].tail = [] <;>h_1I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bx✝:Boolheq✝:decide (P a) = true⊢ [a].tail = []h_2I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bx✝:Boolheq✝:decide (P a) = false⊢ [].tail = [] rflAll goals completed! 🐙
  | a :: b :: l, Nat.succ n, h =>I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.takeWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx n.succ) =
  (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx n.succ byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.takeWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx n.succ) =
  (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx n.succ
    simp only [Nat.succ_eq_add_one, List.eraseIdx_cons_succ]I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.takeWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx (n + 1)
    by_cases hPa : P aposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx (n + 1)negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPa:¬P a⊢ List.takeWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx (n + 1)
    ·posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPa:P a⊢ List.takeWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx (n + 1) dsimp only [List.takeWhile]posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPa:P a⊢ (match decide (P a) with
  | true => a :: List.takeWhile (fun b => decide (P b)) ((b :: l).eraseIdx n)
  | false => []) =
  (match decide (P a) with
      | true =>
        a ::
          match decide (P b) with
          | true => b :: List.takeWhile (fun b => decide (P b)) l
          | false => []
      | false => []).eraseIdx
    (n + 1)
      simp only [hPa, decide_true, List.eraseIdx_cons_succ, List.cons.injEq, true_and]posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPa:P a⊢ List.takeWhile (fun b => decide (P b)) ((b :: l).eraseIdx n) =
  (match decide (P b) with
      | true => b :: List.takeWhile (fun b => decide (P b)) l
      | false => []).eraseIdx
    n
      exact takeWhile_eraseIdx P (b :: l) n fun i j hij hP => byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPa:P ai:Fin (b :: l).lengthj:Fin (b :: l).lengthhij:i < jhP:P ((b :: l).get j)⊢ P ((b :: l).get i)
        simpa using h i.succ j.succ (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPa:P ai:Fin (b :: l).lengthj:Fin (b :: l).lengthhij:i < jhP:P ((b :: l).get j)⊢ i.succ < j.succ simpa using hijAll goals completed! 🐙) (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPa:P ai:Fin (b :: l).lengthj:Fin (b :: l).lengthhij:i < jhP:P ((b :: l).get j)⊢ P ((a :: b :: l).get j.succ) simpa using hPAll goals completed! 🐙)
    ·negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPa:¬P a⊢ List.takeWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx (n + 1) simp [hPa]All goals completed! 🐙

lemma dropWile_eraseIdx {I : Type} (P : I → Prop) [DecidablePred P] :
    (l : List I) → (i : ℕ) → (hi : ∀ (i j : Fin l.length), i < j → P (l.get j) → P (l.get i)) →
    List.dropWhile P (List.eraseIdx l i) =
      if (List.takeWhile P l).length ≤ i then
        (List.dropWhile P l).eraseIdx (i - (List.takeWhile P l).length)
      else (List.dropWhile P l)
  | [], _, h =>I:TypeP:I → Propinst✝:DecidablePred Px✝:ℕh:∀ (i j : Fin [].length), i < j → P ([].get j) → P ([].get i)⊢ List.dropWhile (fun b => decide (P b)) ([].eraseIdx x✝) =
  if (List.takeWhile (fun b => decide (P b)) []).length ≤ x✝ then
    (List.dropWhile (fun b => decide (P b)) []).eraseIdx (x✝ - (List.takeWhile (fun b => decide (P b)) []).length)
  else List.dropWhile (fun b => decide (P b)) [] byI:TypeP:I → Propinst✝:DecidablePred Px✝:ℕh:∀ (i j : Fin [].length), i < j → P ([].get j) → P ([].get i)⊢ List.dropWhile (fun b => decide (P b)) ([].eraseIdx x✝) =
  if (List.takeWhile (fun b => decide (P b)) []).length ≤ x✝ then
    (List.dropWhile (fun b => decide (P b)) []).eraseIdx (x✝ - (List.takeWhile (fun b => decide (P b)) []).length)
  else List.dropWhile (fun b => decide (P b)) []
    simpAll goals completed! 🐙
  | a :: [], 0, h =>I:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (0 - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a] byI:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (0 - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a]
    by_cases hPa : P aposI:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)hPa:P a⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (0 - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a]negI:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)hPa:¬P a⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (0 - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a] <;>posI:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)hPa:P a⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (0 - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a]negI:TypeP:I → Propinst✝:DecidablePred Pa:Ih:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)hPa:¬P a⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (0 - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a] simp [hPa]All goals completed! 🐙
  | a :: [], Nat.succ n, h =>I:TypeP:I → Propinst✝:DecidablePred Pa:In:ℕh:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx n.succ) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ n.succ then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (n.succ - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a] byI:TypeP:I → Propinst✝:DecidablePred Pa:In:ℕh:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx n.succ) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ n.succ then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (n.succ - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a]
    by_cases hPa : P aposI:TypeP:I → Propinst✝:DecidablePred Pa:In:ℕh:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)hPa:P a⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx n.succ) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ n.succ then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (n.succ - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a]negI:TypeP:I → Propinst✝:DecidablePred Pa:In:ℕh:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)hPa:¬P a⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx n.succ) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ n.succ then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (n.succ - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a] <;>posI:TypeP:I → Propinst✝:DecidablePred Pa:In:ℕh:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)hPa:P a⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx n.succ) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ n.succ then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (n.succ - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a]negI:TypeP:I → Propinst✝:DecidablePred Pa:In:ℕh:∀ (i j : Fin [a].length), i < j → P ([a].get j) → P ([a].get i)hPa:¬P a⊢ List.dropWhile (fun b => decide (P b)) ([a].eraseIdx n.succ) =
  if (List.takeWhile (fun b => decide (P b)) [a]).length ≤ n.succ then
    (List.dropWhile (fun b => decide (P b)) [a]).eraseIdx (n.succ - (List.takeWhile (fun b => decide (P b)) [a]).length)
  else List.dropWhile (fun b => decide (P b)) [a] simp [hPa, List.eraseIdx_of_length_le]All goals completed! 🐙
  | a :: b :: l, 0, h =>I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)
    by_cases hPb : P bposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P b⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)
    ·posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) have hPa : P a := by
        simpa using h ⟨0, byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ 0 < (a :: b :: l).lengthposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) simpAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)⟩ ⟨1, byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ 1 < (a :: b :: l).lengthposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) simpAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)⟩ (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ ⟨0, ⋯⟩ < ⟨1, ⋯⟩posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) simpAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)) (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ P ((a :: b :: l).get ⟨1, ⋯⟩)posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) simpa using hPbAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l))posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)
      simp [hPb, hPa]All goals completed! 🐙
    ·negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P b⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) by_cases hPa : P aposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:¬P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) <;>posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List Ih:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:¬P a⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx 0) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ 0 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (0 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) simp [hPa, hPb]All goals completed! 🐙
  | a :: b :: l, Nat.succ n, h =>I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx n.succ) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n.succ then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n.succ - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx n.succ) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n.succ then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n.succ - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)
    simp only [Nat.succ_eq_add_one, List.eraseIdx_cons_succ]I:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)
    by_cases hPb : P bposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P b⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)
    ·posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) have hPa : P a := byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)⊢ List.dropWhile (fun b => decide (P b)) ((a :: b :: l).eraseIdx n.succ) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n.succ then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n.succ - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)
        simpa using h ⟨0, byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ 0 < (a :: b :: l).lengthposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) simpAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)⟩ ⟨1, byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ 1 < (a :: b :: l).lengthposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) simpAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)⟩ (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ ⟨0, ⋯⟩ < ⟨1, ⋯⟩posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) simpAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)) (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P b⊢ P ((a :: b :: l).get ⟨1, ⋯⟩)posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) simpa using hPbAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l))posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l)
      simp only [List.dropWhile, hPa, decide_true, List.takeWhile, hPb, List.length_cons,
        add_le_add_iff_right, Nat.reduceSubDiff]posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ List.dropWhile (fun b => decide (P b)) ((b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) l).length + 1 ≤ n then
    (List.dropWhile (fun b => decide (P b)) l).eraseIdx (n - ((List.takeWhile (fun b => decide (P b)) l).length + 1))
  else List.dropWhile (fun b => decide (P b)) l
      rw [dropWile_eraseIdx P (b :: l) n (fun i j hij hP => byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P ai:Fin (b :: l).lengthj:Fin (b :: l).lengthhij:i < jhP:P ((b :: l).get j)⊢ P ((b :: l).get i)posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ (if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
    (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
      (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (b :: l)) =
  if (List.takeWhile (fun b => decide (P b)) l).length + 1 ≤ n then
    (List.dropWhile (fun b => decide (P b)) l).eraseIdx (n - ((List.takeWhile (fun b => decide (P b)) l).length + 1))
  else List.dropWhile (fun b => decide (P b)) l
        simpa using h i.succ j.succ (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P ai:Fin (b :: l).lengthj:Fin (b :: l).lengthhij:i < jhP:P ((b :: l).get j)⊢ i.succ < j.succposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ (if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
    (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
      (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (b :: l)) =
  if (List.takeWhile (fun b => decide (P b)) l).length + 1 ≤ n then
    (List.dropWhile (fun b => decide (P b)) l).eraseIdx (n - ((List.takeWhile (fun b => decide (P b)) l).length + 1))
  else List.dropWhile (fun b => decide (P b)) l simpa using hijAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ (if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
    (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
      (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (b :: l)) =
  if (List.takeWhile (fun b => decide (P b)) l).length + 1 ≤ n then
    (List.dropWhile (fun b => decide (P b)) l).eraseIdx (n - ((List.takeWhile (fun b => decide (P b)) l).length + 1))
  else List.dropWhile (fun b => decide (P b)) l) (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P ai:Fin (b :: l).lengthj:Fin (b :: l).lengthhij:i < jhP:P ((b :: l).get j)⊢ P ((a :: b :: l).get j.succ)posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ (if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
    (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
      (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (b :: l)) =
  if (List.takeWhile (fun b => decide (P b)) l).length + 1 ≤ n then
    (List.dropWhile (fun b => decide (P b)) l).eraseIdx (n - ((List.takeWhile (fun b => decide (P b)) l).length + 1))
  else List.dropWhile (fun b => decide (P b)) l simpa using hPAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ (if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
    (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
      (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (b :: l)) =
  if (List.takeWhile (fun b => decide (P b)) l).length + 1 ≤ n then
    (List.dropWhile (fun b => decide (P b)) l).eraseIdx (n - ((List.takeWhile (fun b => decide (P b)) l).length + 1))
  else List.dropWhile (fun b => decide (P b)) l))]posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:P bhPa:P a⊢ (if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
    (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
      (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (b :: l)) =
  if (List.takeWhile (fun b => decide (P b)) l).length + 1 ≤ n then
    (List.dropWhile (fun b => decide (P b)) l).eraseIdx (n - ((List.takeWhile (fun b => decide (P b)) l).length + 1))
  else List.dropWhile (fun b => decide (P b)) l
      simp_all only [List.length_cons, List.get_eq_getElem, decide_true, List.takeWhile_cons_of_pos,
        List.dropWhile_cons_of_pos]All goals completed! 🐙
    ·negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P b⊢ List.dropWhile (fun b => decide (P b)) (a :: (b :: l).eraseIdx n) =
  if (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length ≤ n + 1 then
    (List.dropWhile (fun b => decide (P b)) (a :: b :: l)).eraseIdx
      (n + 1 - (List.takeWhile (fun b => decide (P b)) (a :: b :: l)).length)
  else List.dropWhile (fun b => decide (P b)) (a :: b :: l) simp only [List.dropWhile, List.takeWhile, hPb, decide_false]negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P b⊢ (match decide (P a) with
  | true => List.dropWhile (fun b => decide (P b)) ((b :: l).eraseIdx n)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: l
      by_cases hPa : P aposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P a⊢ (match decide (P a) with
  | true => List.dropWhile (fun b => decide (P b)) ((b :: l).eraseIdx n)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: lnegI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:¬P a⊢ (match decide (P a) with
  | true => List.dropWhile (fun b => decide (P b)) ((b :: l).eraseIdx n)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: l
      ·posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P a⊢ (match decide (P a) with
  | true => List.dropWhile (fun b => decide (P b)) ((b :: l).eraseIdx n)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: l rw [dropWile_eraseIdx P (b :: l) n (fun i j hij hP => byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P ai:Fin (b :: l).lengthj:Fin (b :: l).lengthhij:i < jhP:P ((b :: l).get j)⊢ P ((b :: l).get i)posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P a⊢ (match decide (P a) with
  | true =>
    if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
      (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
        (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
    else List.dropWhile (fun b => decide (P b)) (b :: l)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: l
          simpa using h i.succ j.succ (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P ai:Fin (b :: l).lengthj:Fin (b :: l).lengthhij:i < jhP:P ((b :: l).get j)⊢ i.succ < j.succposI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P a⊢ (match decide (P a) with
  | true =>
    if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
      (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
        (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
    else List.dropWhile (fun b => decide (P b)) (b :: l)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: l simpa using hijAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P a⊢ (match decide (P a) with
  | true =>
    if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
      (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
        (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
    else List.dropWhile (fun b => decide (P b)) (b :: l)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: l) (byI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P ai:Fin (b :: l).lengthj:Fin (b :: l).lengthhij:i < jhP:P ((b :: l).get j)⊢ P ((a :: b :: l).get j.succ)posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P a⊢ (match decide (P a) with
  | true =>
    if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
      (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
        (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
    else List.dropWhile (fun b => decide (P b)) (b :: l)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: l simpa using hPAll goals completed! 🐙posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P a⊢ (match decide (P a) with
  | true =>
    if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
      (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
        (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
    else List.dropWhile (fun b => decide (P b)) (b :: l)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: l))]posI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:P a⊢ (match decide (P a) with
  | true =>
    if (List.takeWhile (fun b => decide (P b)) (b :: l)).length ≤ n then
      (List.dropWhile (fun b => decide (P b)) (b :: l)).eraseIdx
        (n - (List.takeWhile (fun b => decide (P b)) (b :: l)).length)
    else List.dropWhile (fun b => decide (P b)) (b :: l)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: l
        simp only [hPa, decide_true, hPb, decide_false, Bool.false_eq_true, not_false_eq_true,
          List.takeWhile_cons_of_neg, List.length_nil, zero_le, ↓reduceIte, List.dropWhile,
          tsub_zero, List.length_singleton, le_add_iff_nonneg_left, add_tsub_cancel_right]All goals completed! 🐙
      ·negI:TypeP:I → Propinst✝:DecidablePred Pa:Ib:Il:List In:ℕh:∀ (i j : Fin (a :: b :: l).length), i < j → P ((a :: b :: l).get j) → P ((a :: b :: l).get i)hPb:¬P bhPa:¬P a⊢ (match decide (P a) with
  | true => List.dropWhile (fun b => decide (P b)) ((b :: l).eraseIdx n)
  | false => a :: (b :: l).eraseIdx n) =
  if
      (match decide (P a) with
          | true => [a]
          | false => []).length ≤
        n + 1 then
    (match decide (P a) with
        | true => b :: l
        | false => a :: b :: l).eraseIdx
      (n + 1 -
        (match decide (P a) with
          | true => [a]
          | false => []).length)
  else
    match decide (P a) with
    | true => b :: l
    | false => a :: b :: l simp [hPa]All goals completed! 🐙lemma insertionSort_length {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (l : List I) :
    (List.insertionSort le1 l).length = l.length :=
  List.length_insertionSort le1 l

The position r0 ends up in r on adding it via List.orderedInsert _ r0 r.


@[`@[expose]` has no effect outside a `module` fileexpose]
def orderedInsertPos {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I) (r0 : I) :
    Fin (List.orderedInsert le1 r0 r).length :=
  ⟨(List.takeWhile (fun b => decide ¬ le1 r0 b) r).length, byn:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length < (List.orderedInsert le1 r0 r).length
    rw [List.orderedInsert_lengthn:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length < r.length + 1n:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length < r.length + 1]n:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length < r.length + 1
    have h1 : (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ r.length :=
      List.Sublist.length_le (List.takeWhile_sublist fun b => decide ¬le1 r0 b)n:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ih1:(List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ r.length⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length < r.length + 1
    omegaAll goals completed! 🐙⟩

              lemma orderedInsertPos_lt_length {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
    (r0 : I) : orderedInsertPos le1 r r0 < (r0 :: r).length := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ ↑(orderedInsertPos le1 r r0) < (r0 :: r).length
  simp only [orderedInsertPos, List.length_cons]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length < r.length + 1
  exact Nat.lt_succ_of_le (List.takeWhile_sublist _).length_leAll goals completed! 🐙@[simp]
lemma orderedInsert_get_orderedInsertPos {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) :
    (List.orderedInsert le1 r0 r)[(orderedInsertPos le1 r r0).val] = r0 := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.orderedInsert le1 r0 r)[↑(orderedInsertPos le1 r r0)] = r0
  simp [List.orderedInsert_eq_take_drop, orderedInsertPos]All goals completed! 🐙

@[simp]
lemma orderedInsert_eraseIdx_orderedInsertPos {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) :
    (List.orderedInsert le1 r0 r).eraseIdx ↑(orderedInsertPos le1 r r0) = r := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.orderedInsert le1 r0 r).eraseIdx ↑(orderedInsertPos le1 r r0) = r
  simp only [List.orderedInsert_eq_take_drop]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r ++ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    ↑(orderedInsertPos le1 r r0) =
  r
  rw [List.eraseIdx_append_of_length_leI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r ++
    (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
      (↑(orderedInsertPos le1 r r0) - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  rhkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ↑(orderedInsertPos le1 r r0)I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r ++
    (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
      (↑(orderedInsertPos le1 r r0) - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  rhkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ↑(orderedInsertPos le1 r r0)]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r ++
    (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
      (↑(orderedInsertPos le1 r r0) - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  rhkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ↑(orderedInsertPos le1 r r0)
  ·I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r ++
    (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
      (↑(orderedInsertPos le1 r r0) - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  r simp [orderedInsertPos]All goals completed! 🐙
  ·hkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ↑(orderedInsertPos le1 r r0) rflAll goals completed! 🐙lemma orderedInsertPos_cons {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 r1 : I) :
    (orderedInsertPos le1 (r1 ::r) r0).val =
    if le1 r0 r1 then ⟨0, byn:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ir1:I⊢ 0 < (List.orderedInsert le1 r0 r).length + 1 simpAll goals completed! 🐙⟩ else (Fin.succ (orderedInsertPos le1 r r0)) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ir1:I⊢ ↑(orderedInsertPos le1 (r1 :: r) r0) = ↑(if le1 r0 r1 then ⟨0, ⋯⟩ else (orderedInsertPos le1 r r0).succ)
  simp only [orderedInsertPos, List.takeWhile, decide_not, Fin.zero_eta,
    Fin.succ_mk]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ir1:I⊢ (match !decide (le1 r0 r1) with
    | true => r1 :: List.takeWhile (fun b => !decide (le1 r0 b)) r
    | false => []).length =
  ↑(if le1 r0 r1 then 0 else ⟨(List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1, ⋯⟩)
  by_cases h : le1 r0 r1posI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ir1:Ih:le1 r0 r1⊢ (match !decide (le1 r0 r1) with
    | true => r1 :: List.takeWhile (fun b => !decide (le1 r0 b)) r
    | false => []).length =
  ↑(if le1 r0 r1 then 0 else ⟨(List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1, ⋯⟩)negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ir1:Ih:¬le1 r0 r1⊢ (match !decide (le1 r0 r1) with
    | true => r1 :: List.takeWhile (fun b => !decide (le1 r0 b)) r
    | false => []).length =
  ↑(if le1 r0 r1 then 0 else ⟨(List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1, ⋯⟩) <;>posI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ir1:Ih:le1 r0 r1⊢ (match !decide (le1 r0 r1) with
    | true => r1 :: List.takeWhile (fun b => !decide (le1 r0 b)) r
    | false => []).length =
  ↑(if le1 r0 r1 then 0 else ⟨(List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1, ⋯⟩)negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ir1:Ih:¬le1 r0 r1⊢ (match !decide (le1 r0 r1) with
    | true => r1 :: List.takeWhile (fun b => !decide (le1 r0 b)) r
    | false => []).length =
  ↑(if le1 r0 r1 then 0 else ⟨(List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1, ⋯⟩) simp [h]All goals completed! 🐙lemma orderedInsertPos_sigma {I : Type} {f : I → Type}
    (le1 : I → I → Prop) [DecidableRel le1] (l : List (Σ i, f i))
    (k : I) (a : f k) :
    (orderedInsertPos (fun (i j : Σ i, f i) => le1 i.1 j.1) l ⟨k, a⟩).1 =
    (orderedInsertPos le1 (List.map (fun (i : Σ i, f i) => i.1) l) k).1 := byI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)k:Ia:f k⊢ ↑(orderedInsertPos (fun i j => le1 i.fst j.fst) l ⟨k, a⟩) = ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) k)
  simp only [orderedInsertPos, decide_not]I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)k:Ia:f k⊢ (List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) l)).length
  induction l with
  | nil =>nilI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1k:Ia:f k⊢ (List.takeWhile (fun b => !decide (le1 k b.fst)) []).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) [])).length
    simpAll goals completed! 🐙
  | cons a l ih =>consI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1k:Ia✝:f ka:(i : I) × f il:List ((i : I) × f i)ih:(List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) l)).length⊢ (List.takeWhile (fun b => !decide (le1 k b.fst)) (a :: l)).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) (a :: l))).length
    simp only [List.takeWhile]consI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1k:Ia✝:f ka:(i : I) × f il:List ((i : I) × f i)ih:(List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) l)).length⊢ (match !decide (le1 k a.fst) with
    | true => a :: List.takeWhile (fun b => !decide (le1 k b.fst)) l
    | false => []).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) (a :: l))).length
    obtain ⟨fst, snd⟩ := aconsI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1k:Ia:f kl:List ((i : I) × f i)ih:(List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) l)).lengthfst:Isnd:f fst⊢ (match !decide (le1 k ⟨fst, snd⟩.fst) with
    | true => ⟨fst, snd⟩ :: List.takeWhile (fun b => !decide (le1 k b.fst)) l
    | false => []).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) (⟨fst, snd⟩ :: l))).length
    simp_all onlyconsI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1k:Ia:f kl:List ((i : I) × f i)ih:(List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) l)).lengthfst:Isnd:f fst⊢ (match !decide (le1 k fst) with
    | true => ⟨fst, snd⟩ :: List.takeWhile (fun b => !decide (le1 k b.fst)) l
    | false => []).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) (⟨fst, snd⟩ :: l))).length
    splith_1I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1k:Ia:f kl:List ((i : I) × f i)ih:(List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) l)).lengthfst:Isnd:f fstx✝:Boolheq✝:(!decide (le1 k fst)) = true⊢ (⟨fst, snd⟩ :: List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) (⟨fst, snd⟩ :: l))).lengthh_2I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1k:Ia:f kl:List ((i : I) × f i)ih:(List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) l)).lengthfst:Isnd:f fstx✝:Boolheq✝:(!decide (le1 k fst)) = false⊢ [].length = (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) (⟨fst, snd⟩ :: l))).length <;>h_1I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1k:Ia:f kl:List ((i : I) × f i)ih:(List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) l)).lengthfst:Isnd:f fstx✝:Boolheq✝:(!decide (le1 k fst)) = true⊢ (⟨fst, snd⟩ :: List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) (⟨fst, snd⟩ :: l))).lengthh_2I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1k:Ia:f kl:List ((i : I) × f i)ih:(List.takeWhile (fun b => !decide (le1 k b.fst)) l).length =
  (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) l)).lengthfst:Isnd:f fstx✝:Boolheq✝:(!decide (le1 k fst)) = false⊢ [].length = (List.takeWhile (fun b => !decide (le1 k b)) (List.map (fun i => i.fst) (⟨fst, snd⟩ :: l))).length simp_allAll goals completed! 🐙

set_option backward.isDefEq.respectTransparency false in
lemma orderedInsert_get_lt {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) (i : ℕ)
    (hi : i < orderedInsertPos le1 r r0) :
    (List.orderedInsert le1 r0 r)[i] = r.get ⟨i, byn:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)⊢ i < r.length
      simp only [orderedInsertPos] at hin:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < (List.takeWhile (fun b => decide ¬le1 r0 b) r).length⊢ i < r.length
      have h1 : (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ r.length :=
        List.Sublist.length_le (List.takeWhile_sublist fun b => decide ¬le1 r0 b)n:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < (List.takeWhile (fun b => decide ¬le1 r0 b) r).lengthh1:(List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ r.length⊢ i < r.length
      omegaAll goals completed! 🐙⟩ := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)⊢ (List.orderedInsert le1 r0 r)[i] = r.get ⟨i, ⋯⟩
  simp only [orderedInsertPos, decide_not] at hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ (List.orderedInsert le1 r0 r)[i] = r.get ⟨i, ⋯⟩
  simp only [List.orderedInsert_eq_take_drop, decide_not, List.get_eq_getElem]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ (List.takeWhile (fun b => !decide (le1 r0 b)) r ++ r0 :: List.dropWhile (fun b => !decide (le1 r0 b)) r)[i] = r[i]
  rw [List.getElem_appendI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ (if h' : i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length then
    (List.takeWhile (fun b => !decide (le1 r0 b)) r)[i]
  else
    (r0 ::
        List.dropWhile (fun b => !decide (le1 r0 b)) r)[i - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]) =
  r[i]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ (if h' : i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length then
    (List.takeWhile (fun b => !decide (le1 r0 b)) r)[i]
  else
    (r0 ::
        List.dropWhile (fun b => !decide (le1 r0 b)) r)[i - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]) =
  r[i]]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ (if h' : i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length then
    (List.takeWhile (fun b => !decide (le1 r0 b)) r)[i]
  else
    (r0 ::
        List.dropWhile (fun b => !decide (le1 r0 b)) r)[i - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]) =
  r[i]
  simp only [hi, ↓reduceDIte]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ (List.takeWhile (fun b => !decide (le1 r0 b)) r)[i] = r[i]
  rw [List.IsPrefix.getElemI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ ?m.64[i] = r[i]hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ List.takeWhile (fun b => !decide (le1 r0 b)) r <+: ?m.64I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ List IhI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ List.takeWhile (fun b => !decide (le1 r0 b)) r <+: r]hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi✝:i < ↑(orderedInsertPos le1 r r0)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ List.takeWhile (fun b => !decide (le1 r0 b)) r <+: r
  exact List.takeWhile_prefix fun b => !decide (le1 r0 b)All goals completed! 🐙lemma orderedInsertPos_take_orderedInsert {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) :
    (List.take (orderedInsertPos le1 r r0) (List.orderedInsert le1 r0 r)) =
    List.takeWhile (fun b => decide ¬le1 r0 b) r := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r) = List.takeWhile (fun b => decide ¬le1 r0 b) r
  simp [orderedInsertPos, List.orderedInsert_eq_take_drop]All goals completed! 🐙

lemma orderedInsertPos_take_eq_orderedInsert {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) :
    List.take (orderedInsertPos le1 r r0) r =
    List.take (orderedInsertPos le1 r r0) (List.orderedInsert le1 r0 r) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.take (↑(orderedInsertPos le1 r r0)) r = List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)
  refine List.ext_get ?_ ?_refine_1I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.take (↑(orderedInsertPos le1 r r0)) r).length =
  (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).lengthrefine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ ∀ (n : ℕ) (h₁ : n < (List.take (↑(orderedInsertPos le1 r r0)) r).length)
  (h₂ : n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length),
  (List.take (↑(orderedInsertPos le1 r r0)) r).get ⟨n, h₁⟩ =
    (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).get ⟨n, h₂⟩
  ·refine_1I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.take (↑(orderedInsertPos le1 r r0)) r).length =
  (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length simp only [List.length_take, Fin.is_le', inf_of_le_left, inf_eq_left]refine_1I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ ↑(orderedInsertPos le1 r r0) ≤ r.length
    exact Nat.le_of_lt_succ (orderedInsertPos_lt_length le1 r r0)All goals completed! 🐙
  ·refine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ ∀ (n : ℕ) (h₁ : n < (List.take (↑(orderedInsertPos le1 r r0)) r).length)
  (h₂ : n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length),
  (List.take (↑(orderedInsertPos le1 r r0)) r).get ⟨n, h₁⟩ =
    (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).get ⟨n, h₂⟩ intro n h1 h2refine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.take (↑(orderedInsertPos le1 r r0)) r).lengthh2:n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length⊢ (List.take (↑(orderedInsertPos le1 r r0)) r).get ⟨n, h1⟩ =
  (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).get ⟨n, h2⟩
    simp only [List.get_eq_getElem, List.getElem_take]refine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.take (↑(orderedInsertPos le1 r r0)) r).lengthh2:n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length⊢ r[n] = (List.orderedInsert le1 r0 r)[n]
    rw [orderedInsert_get_lt le1 r r0 nrefine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.take (↑(orderedInsertPos le1 r r0)) r).lengthh2:n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length⊢ r[n] = r.get ⟨n, ⋯⟩refine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.take (↑(orderedInsertPos le1 r r0)) r).lengthh2:n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length⊢ n < ↑(orderedInsertPos le1 r r0)refine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.take (↑(orderedInsertPos le1 r r0)) r).lengthh2:n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length⊢ r[n] = r.get ⟨n, ⋯⟩refine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.take (↑(orderedInsertPos le1 r r0)) r).lengthh2:n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length⊢ n < ↑(orderedInsertPos le1 r r0)]refine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.take (↑(orderedInsertPos le1 r r0)) r).lengthh2:n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length⊢ r[n] = r.get ⟨n, ⋯⟩refine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.take (↑(orderedInsertPos le1 r r0)) r).lengthh2:n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length⊢ n < ↑(orderedInsertPos le1 r r0)
    rflrefine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.take (↑(orderedInsertPos le1 r r0)) r).lengthh2:n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).length⊢ n < ↑(orderedInsertPos le1 r r0)
    simp only [List.length_take, lt_inf_iff] at h1refine_2I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh2:n < (List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)).lengthh1:n < ↑(orderedInsertPos le1 r r0) ∧ n < r.length⊢ n < ↑(orderedInsertPos le1 r r0)
    exact h1.1All goals completed! 🐙

lemma orderedInsertPos_drop_eq_orderedInsert {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) :
    List.drop (orderedInsertPos le1 r r0) r =
    List.drop (orderedInsertPos le1 r r0).succ (List.orderedInsert le1 r0 r) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.drop (↑(orderedInsertPos le1 r r0)) r = List.drop (↑(orderedInsertPos le1 r r0).succ) (List.orderedInsert le1 r0 r)
  conv_rhs => simp [orderedInsertPos, List.orderedInsert_eq_take_drop]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I| List.dropWhile (fun b => !decide (le1 r0 b)) r
  have hr : r = List.takeWhile (fun b => !decide (le1 r0 b)) r ++
      List.dropWhile (fun b => !decide (le1 r0 b)) r := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.drop (↑(orderedInsertPos le1 r r0)) r = List.drop (↑(orderedInsertPos le1 r r0).succ) (List.orderedInsert le1 r0 r)I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ihr:r = List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r⊢ List.drop (↑(orderedInsertPos le1 r r0)) r = List.dropWhile (fun b => !decide (le1 r0 b)) r
    exact Eq.symm (List.takeWhile_append_dropWhile)I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ihr:r = List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r⊢ List.drop (↑(orderedInsertPos le1 r r0)) r = List.dropWhile (fun b => !decide (le1 r0 b)) rI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ihr:r = List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r⊢ List.drop (↑(orderedInsertPos le1 r r0)) r = List.dropWhile (fun b => !decide (le1 r0 b)) r
  conv_lhs =>
    rhsI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ihr:r = List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r| r
    rw [hr]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ihr:r = List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r| List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r
  rw [List.drop_appendI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ihr:r = List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r⊢ List.drop (↑(orderedInsertPos le1 r r0)) (List.takeWhile (fun b => !decide (le1 r0 b)) r) ++
    List.drop (↑(orderedInsertPos le1 r r0) - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)
      (List.dropWhile (fun b => !decide (le1 r0 b)) r) =
  List.dropWhile (fun b => !decide (le1 r0 b)) rI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ihr:r = List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r⊢ List.drop (↑(orderedInsertPos le1 r r0)) (List.takeWhile (fun b => !decide (le1 r0 b)) r) ++
    List.drop (↑(orderedInsertPos le1 r r0) - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)
      (List.dropWhile (fun b => !decide (le1 r0 b)) r) =
  List.dropWhile (fun b => !decide (le1 r0 b)) r]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ihr:r = List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r⊢ List.drop (↑(orderedInsertPos le1 r r0)) (List.takeWhile (fun b => !decide (le1 r0 b)) r) ++
    List.drop (↑(orderedInsertPos le1 r r0) - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)
      (List.dropWhile (fun b => !decide (le1 r0 b)) r) =
  List.dropWhile (fun b => !decide (le1 r0 b)) r
  simp [orderedInsertPos]All goals completed! 🐙

lemma orderedInsertPos_take {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) :
    List.take (orderedInsertPos le1 r r0) r = List.takeWhile (fun b => decide ¬le1 r0 b) r := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.take (↑(orderedInsertPos le1 r r0)) r = List.takeWhile (fun b => decide ¬le1 r0 b) r
  rw [orderedInsertPos_take_eq_orderedInsert,I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r) = List.takeWhile (fun b => decide ¬le1 r0 b) rAll goals completed! 🐙orderedInsertPos_take_orderedInsertI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r = List.takeWhile (fun b => decide ¬le1 r0 b) rAll goals completed! 🐙]All goals completed! 🐙

lemma orderedInsertPos_drop {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) :
    List.drop (orderedInsertPos le1 r r0) r = List.dropWhile (fun b => decide ¬le1 r0 b) r := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.drop (↑(orderedInsertPos le1 r r0)) r = List.dropWhile (fun b => decide ¬le1 r0 b) r
  rw [orderedInsertPos_drop_eq_orderedInsertI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.drop (↑(orderedInsertPos le1 r r0).succ) (List.orderedInsert le1 r0 r) =
  List.dropWhile (fun b => decide ¬le1 r0 b) rI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.drop (↑(orderedInsertPos le1 r r0).succ) (List.orderedInsert le1 r0 r) =
  List.dropWhile (fun b => decide ¬le1 r0 b) r]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.drop (↑(orderedInsertPos le1 r r0).succ) (List.orderedInsert le1 r0 r) =
  List.dropWhile (fun b => decide ¬le1 r0 b) r
  simp [orderedInsertPos, List.orderedInsert_eq_take_drop]All goals completed! 🐙lemma orderedInsertPos_succ_take_orderedInsert {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) :
    (List.take (orderedInsertPos le1 r r0).succ (List.orderedInsert le1 r0 r)) =
    List.takeWhile (fun b => decide ¬le1 r0 b) r ++ [r0] := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.take (↑(orderedInsertPos le1 r r0).succ) (List.orderedInsert le1 r0 r) =
  List.takeWhile (fun b => decide ¬le1 r0 b) r ++ [r0]
  simp [orderedInsertPos, List.orderedInsert_eq_take_drop, List.take_append]All goals completed! 🐙

lemma lt_orderedInsertPos_rel {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r0 : I) (r : List I) (n : Fin r.length)
    (hn : n.val < (orderedInsertPos le1 r r0).val) : ¬ le1 r0 (r.get n) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)⊢ ¬le1 r0 (r.get n)
  have htake : r.get n ∈ List.take (orderedInsertPos le1 r r0) r := by
    rw [@List.mem_take_iff_getElemI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)⊢ ∃ j, ∃ (hm : j < min (↑(orderedInsertPos le1 r r0)) r.length), r[j] = r.get nI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)⊢ ∃ j, ∃ (hm : j < min (↑(orderedInsertPos le1 r r0)) r.length), r[j] = r.get nI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)htake:r.get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 (r.get n)]I:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)⊢ ∃ j, ∃ (hm : j < min (↑(orderedInsertPos le1 r r0)) r.length), r[j] = r.get nI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)htake:r.get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 (r.get n)
    use nhI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)⊢ ∃ (hm : ↑n < min (↑(orderedInsertPos le1 r r0)) r.length), r[↑n] = r.get nI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)htake:r.get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 (r.get n)
    simpa only [List.get_eq_getElem, lt_inf_iff, Fin.is_lt, and_true, exists_prop] using hnI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)htake:r.get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 (r.get n)I:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)htake:r.get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 (r.get n)
  rw [orderedInsertPos_takeI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)htake:r.get n ∈ List.takeWhile (fun b => decide ¬le1 r0 b) r⊢ ¬le1 r0 (r.get n)I:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)htake:r.get n ∈ List.takeWhile (fun b => decide ¬le1 r0 b) r⊢ ¬le1 r0 (r.get n)] at htakeI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin r.lengthhn:↑n < ↑(orderedInsertPos le1 r r0)htake:r.get n ∈ List.takeWhile (fun b => decide ¬le1 r0 b) r⊢ ¬le1 r0 (r.get n)
  simpa using List.mem_takeWhile_imp htakeAll goals completed! 🐙

lemma lt_orderedInsertPos_rel_fin {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r0 : I) (r : List I) (n : Fin (List.orderedInsert le1 r0 r).length)
    (hn : n < (orderedInsertPos le1 r r0)) : ¬ le1 r0 ((List.orderedInsert le1 r0 r).get n) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0⊢ ¬le1 r0 ((List.orderedInsert le1 r0 r).get n)
  have htake : (List.orderedInsert le1 r0 r).get n ∈ List.take (orderedInsertPos le1 r r0) r := by
    rw [orderedInsertPos_take_eq_orderedInsert,I:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0⊢ (List.orderedInsert le1 r0 r).get n ∈ List.take (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r)I:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0⊢ ∃ j,
  ∃ (hm : j < min (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r).length),
    (List.orderedInsert le1 r0 r)[j] = (List.orderedInsert le1 r0 r).get nI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0htake:(List.orderedInsert le1 r0 r).get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 ((List.orderedInsert le1 r0 r).get n) List.mem_take_iff_getElemI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0⊢ ∃ j,
  ∃ (hm : j < min (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r).length),
    (List.orderedInsert le1 r0 r)[j] = (List.orderedInsert le1 r0 r).get nI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0⊢ ∃ j,
  ∃ (hm : j < min (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r).length),
    (List.orderedInsert le1 r0 r)[j] = (List.orderedInsert le1 r0 r).get nI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0htake:(List.orderedInsert le1 r0 r).get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 ((List.orderedInsert le1 r0 r).get n)]I:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0⊢ ∃ j,
  ∃ (hm : j < min (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r).length),
    (List.orderedInsert le1 r0 r)[j] = (List.orderedInsert le1 r0 r).get nI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0htake:(List.orderedInsert le1 r0 r).get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 ((List.orderedInsert le1 r0 r).get n)
    use nhI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0⊢ ∃ (hm : ↑n < min (↑(orderedInsertPos le1 r r0)) (List.orderedInsert le1 r0 r).length),
  (List.orderedInsert le1 r0 r)[↑n] = (List.orderedInsert le1 r0 r).get nI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0htake:(List.orderedInsert le1 r0 r).get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 ((List.orderedInsert le1 r0 r).get n)
    simpa only [List.get_eq_getElem, Fin.is_le', inf_of_le_left, Fin.val_fin_lt, exists_prop,
      and_true] using hnI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0htake:(List.orderedInsert le1 r0 r).get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 ((List.orderedInsert le1 r0 r).get n)I:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0htake:(List.orderedInsert le1 r0 r).get n ∈ List.take (↑(orderedInsertPos le1 r r0)) r⊢ ¬le1 r0 ((List.orderedInsert le1 r0 r).get n)
  rw [orderedInsertPos_takeI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0htake:(List.orderedInsert le1 r0 r).get n ∈ List.takeWhile (fun b => decide ¬le1 r0 b) r⊢ ¬le1 r0 ((List.orderedInsert le1 r0 r).get n)I:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0htake:(List.orderedInsert le1 r0 r).get n ∈ List.takeWhile (fun b => decide ¬le1 r0 b) r⊢ ¬le1 r0 ((List.orderedInsert le1 r0 r).get n)] at htakeI:Typele1:I → I → Propinst✝:DecidableRel le1r0:Ir:List In:Fin (List.orderedInsert le1 r0 r).lengthhn:n < orderedInsertPos le1 r r0htake:(List.orderedInsert le1 r0 r).get n ∈ List.takeWhile (fun b => decide ¬le1 r0 b) r⊢ ¬le1 r0 ((List.orderedInsert le1 r0 r).get n)
  simpa using List.mem_takeWhile_imp htakeAll goals completed! 🐙

lemma gt_orderedInsertPos_rel {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    [Std.Total le1] [IsTrans I le1] (r0 : I) (r : List I) (hs : List.Pairwise le1 r)
    (n : Fin r.length)
    (hn : ¬ n.val < (orderedInsertPos le1 r r0).val) : le1 r0 (r.get n) := byI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ le1 r0 (r.get n)
  apply List.Pairwise.rel_of_mem_take_of_mem_drop (i := (orderedInsertPos le1 r r0).succ)
    (List.Pairwise.orderedInsert r0 r hs)hxI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ r0 ∈ List.take (↑(orderedInsertPos le1 r r0).succ) (List.orderedInsert le1 r0 r)hyI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ r.get n ∈ List.drop (↑(orderedInsertPos le1 r r0).succ) (List.orderedInsert le1 r0 r)
  ·hxI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ r0 ∈ List.take (↑(orderedInsertPos le1 r r0).succ) (List.orderedInsert le1 r0 r) rw [orderedInsertPos_succ_take_orderedInserthxI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ r0 ∈ List.takeWhile (fun b => decide ¬le1 r0 b) r ++ [r0]hxI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ r0 ∈ List.takeWhile (fun b => decide ¬le1 r0 b) r ++ [r0]]hxI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ r0 ∈ List.takeWhile (fun b => decide ¬le1 r0 b) r ++ [r0]
    simpAll goals completed! 🐙
  ·hyI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ r.get n ∈ List.drop (↑(orderedInsertPos le1 r r0).succ) (List.orderedInsert le1 r0 r) rw [← orderedInsertPos_drop_eq_orderedInserthyI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ r.get n ∈ List.drop (↑(orderedInsertPos le1 r r0)) rhyI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ r.get n ∈ List.drop (↑(orderedInsertPos le1 r r0)) r]hyI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ r.get n ∈ List.drop (↑(orderedInsertPos le1 r r0)) r
    refine List.mem_drop_iff_getElem.mpr ?_hyI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ ∃ j, ∃ (hm : j + ↑(orderedInsertPos le1 r r0) < r.length), r[↑(orderedInsertPos le1 r r0) + j] = r.get n
    use n - (orderedInsertPos le1 r r0).valhI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ ∃ (hm : ↑n - ↑(orderedInsertPos le1 r r0) + ↑(orderedInsertPos le1 r r0) < r.length),
  r[↑(orderedInsertPos le1 r r0) + (↑n - ↑(orderedInsertPos le1 r r0))] = r.get n
    have hn : ↑n - ↑(orderedInsertPos le1 r r0) + ↑(orderedInsertPos le1 r r0) < r.length := byI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn:¬↑n < ↑(orderedInsertPos le1 r r0)⊢ le1 r0 (r.get n)hI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn✝:¬↑n < ↑(orderedInsertPos le1 r r0)hn:↑n - ↑(orderedInsertPos le1 r r0) + ↑(orderedInsertPos le1 r r0) < r.length⊢ ∃ (hm : ↑n - ↑(orderedInsertPos le1 r r0) + ↑(orderedInsertPos le1 r r0) < r.length),
  r[↑(orderedInsertPos le1 r r0) + (↑n - ↑(orderedInsertPos le1 r r0))] = r.get n
      omegahI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn✝:¬↑n < ↑(orderedInsertPos le1 r r0)hn:↑n - ↑(orderedInsertPos le1 r r0) + ↑(orderedInsertPos le1 r r0) < r.length⊢ ∃ (hm : ↑n - ↑(orderedInsertPos le1 r r0) + ↑(orderedInsertPos le1 r r0) < r.length),
  r[↑(orderedInsertPos le1 r r0) + (↑n - ↑(orderedInsertPos le1 r r0))] = r.get nhI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn✝:¬↑n < ↑(orderedInsertPos le1 r r0)hn:↑n - ↑(orderedInsertPos le1 r r0) + ↑(orderedInsertPos le1 r r0) < r.length⊢ ∃ (hm : ↑n - ↑(orderedInsertPos le1 r r0) + ↑(orderedInsertPos le1 r r0) < r.length),
  r[↑(orderedInsertPos le1 r r0) + (↑n - ↑(orderedInsertPos le1 r r0))] = r.get n
    use hnhI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn✝:¬↑n < ↑(orderedInsertPos le1 r r0)hn:↑n - ↑(orderedInsertPos le1 r r0) + ↑(orderedInsertPos le1 r r0) < r.length⊢ r[↑(orderedInsertPos le1 r r0) + (↑n - ↑(orderedInsertPos le1 r r0))] = r.get n
    congrh.e_iI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihs:List.Pairwise le1 rn:Fin r.lengthhn✝:¬↑n < ↑(orderedInsertPos le1 r r0)hn:↑n - ↑(orderedInsertPos le1 r r0) + ↑(orderedInsertPos le1 r r0) < r.length⊢ ↑(orderedInsertPos le1 r r0) + (↑n - ↑(orderedInsertPos le1 r r0)) = ↑n
    omegaAll goals completed! 🐙

lemma orderedInsert_eraseIdx_lt_orderedInsertPos {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) (i : ℕ)
    (hi : i < orderedInsertPos le1 r r0)
    (hr : ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) :
    (List.orderedInsert le1 r0 r).eraseIdx i = List.orderedInsert le1 r0 (r.eraseIdx i) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.orderedInsert le1 r0 r).eraseIdx i = List.orderedInsert le1 r0 (r.eraseIdx i)
  conv_lhs => simp only [List.orderedInsert_eq_take_drop]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)| (List.takeWhile (fun b => decide ¬le1 r0 b) r ++ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx i
  rw [List.eraseIdx_append_of_lt_lengthI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).eraseIdx i ++ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  List.orderedInsert le1 r0 (r.eraseIdx i)hkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ i < (List.takeWhile (fun b => decide ¬le1 r0 b) r).lengthI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).eraseIdx i ++ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  List.orderedInsert le1 r0 (r.eraseIdx i)hkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ i < (List.takeWhile (fun b => decide ¬le1 r0 b) r).length]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).eraseIdx i ++ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  List.orderedInsert le1 r0 (r.eraseIdx i)hkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ i < (List.takeWhile (fun b => decide ¬le1 r0 b) r).length
  ·I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).eraseIdx i ++ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  List.orderedInsert le1 r0 (r.eraseIdx i) simp only [List.orderedInsert_eq_take_drop]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).eraseIdx i ++ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  List.takeWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i) ++
    r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)
    congr 1e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).eraseIdx i = List.takeWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r = r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)
    ·e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).eraseIdx i = List.takeWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i) rw [takeWhile_eraseIdxe_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).eraseIdx i = (List.takeWhile (fun b => decide ¬le1 r0 b) r).eraseIdx ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)e_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)]e_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)
      exact hrAll goals completed! 🐙
    ·e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r = r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i) rw [dropWile_eraseIdxe_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  r0 ::
    if (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i then
      (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
        (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length)
    else List.dropWhile (fun b => decide ¬le1 r0 b) re_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  r0 ::
    if (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i then
      (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
        (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length)
    else List.dropWhile (fun b => decide ¬le1 r0 b) re_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)]e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  r0 ::
    if (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i then
      (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
        (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length)
    else List.dropWhile (fun b => decide ¬le1 r0 b) re_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)
      simp only [orderedInsertPos, decide_not] at hie_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  r0 ::
    if (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i then
      (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
        (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length)
    else List.dropWhile (fun b => decide ¬le1 r0 b) re_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)
      have hi' : ¬ (List.takeWhile (fun b => !decide (le1 r0 b)) r).length ≤ ↑i := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.orderedInsert le1 r0 r).eraseIdx i = List.orderedInsert le1 r0 (r.eraseIdx i)e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhi':¬(List.takeWhile (fun b => !decide (le1 r0 b)) r).length ≤ i⊢ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  r0 ::
    if (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i then
      (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
        (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length)
    else List.dropWhile (fun b => decide ¬le1 r0 b) re_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i) omegae_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhi':¬(List.takeWhile (fun b => !decide (le1 r0 b)) r).length ≤ i⊢ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  r0 ::
    if (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i then
      (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
        (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length)
    else List.dropWhile (fun b => decide ¬le1 r0 b) re_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hi:i < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhi':¬(List.takeWhile (fun b => !decide (le1 r0 b)) r).length ≤ i⊢ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r =
  r0 ::
    if (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i then
      (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
        (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length)
    else List.dropWhile (fun b => decide ¬le1 r0 b) re_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)
      simp only [decide_not, hi', ↓reduceIte]e_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)
      exact fun i j a a_1 => hr i j a a_1All goals completed! 🐙
  ·hkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:i < ↑(orderedInsertPos le1 r r0)hr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ i < (List.takeWhile (fun b => decide ¬le1 r0 b) r).length exact hiAll goals completed! 🐙

lemma orderedInsert_eraseIdx_orderedInsertPos_le {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) (i : ℕ)
    (hi : orderedInsertPos le1 r r0 ≤ i)
    (hr : ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) :
    (List.orderedInsert le1 r0 r).eraseIdx (Nat.succ i) =
    List.orderedInsert le1 r0 (r.eraseIdx i) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.orderedInsert le1 r0 r).eraseIdx i.succ = List.orderedInsert le1 r0 (r.eraseIdx i)
  conv_lhs => simp only [List.orderedInsert_eq_take_drop]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)| (List.takeWhile (fun b => decide ¬le1 r0 b) r ++ r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx i.succ
  rw [List.eraseIdx_append_of_length_leI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r ++
    (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
      (i.succ - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  List.orderedInsert le1 r0 (r.eraseIdx i)hkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i.succI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r ++
    (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
      (i.succ - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  List.orderedInsert le1 r0 (r.eraseIdx i)hkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i.succ]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r ++
    (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
      (i.succ - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  List.orderedInsert le1 r0 (r.eraseIdx i)hkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i.succ
  ·I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r ++
    (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
      (i.succ - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  List.orderedInsert le1 r0 (r.eraseIdx i) simp only [List.orderedInsert_eq_take_drop]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r ++
    (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
      (i.succ - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  List.takeWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i) ++
    r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)
    congr 1e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r = List.takeWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    (i.succ - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)
    ·e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r = List.takeWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i) rw [takeWhile_eraseIdx,e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r = (List.takeWhile (fun b => decide ¬le1 r0 b) r).eraseIdx ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i) List.eraseIdx_of_length_lee_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ List.takeWhile (fun b => decide ¬le1 r0 b) r = List.takeWhile (fun b => decide ¬le1 r0 b) re_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)]e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)
      simp only [orderedInsertPos, decide_not] at hie_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hi:(List.takeWhile (fun b => !decide (le1 r0 b)) r).length ≤ i⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)
      simp only [decide_not]e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hi:(List.takeWhile (fun b => !decide (le1 r0 b)) r).length ≤ i⊢ (List.takeWhile (fun b => !decide (le1 r0 b)) r).length ≤ ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)
      omegae_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)
      exact hrAll goals completed! 🐙
    ·e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    (i.succ - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i) simp only [Nat.succ_eq_add_one]e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    (i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)
      have hn : (i + 1 - (List.takeWhile (fun b => (decide (¬ le1 r0 b))) r).length)
        = (i - (List.takeWhile (fun b => decide (¬ le1 r0 b)) r).length) + 1 := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.orderedInsert le1 r0 r).eraseIdx i.succ = List.orderedInsert le1 r0 (r.eraseIdx i)e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    (i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)
        simp only [orderedInsertPos] at hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:(List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    (i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)
        omegae_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    (i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    (i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)
      rw [hne_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1) =
  r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1) =
  r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)]e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx
    (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1) =
  r0 :: List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)
      simp only [List.eraseIdx_cons_succ, List.cons.injEq, true_and]e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  List.dropWhile (fun b => decide ¬le1 r0 b) (r.eraseIdx i)
      rw [dropWile_eraseIdx,e_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  if (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i then
    (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length)
  else List.dropWhile (fun b => decide ¬le1 r0 b) re_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)e_a.hcI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i) if_pose_aI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length) =
  (List.dropWhile (fun b => decide ¬le1 r0 b) r).eraseIdx (i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length)e_a.hcI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)e_a.hcI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)]e_a.hcI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ie_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)
      ·e_a.hcI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i rw [orderedInsertPose_a.hcI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑⟨(List.takeWhile (fun b => decide ¬le1 r0 b) r).length, ⋯⟩ ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ie_a.hcI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑⟨(List.takeWhile (fun b => decide ¬le1 r0 b) r).length, ⋯⟩ ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i] at hie_a.hcI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑⟨(List.takeWhile (fun b => decide ¬le1 r0 b) r).length, ⋯⟩ ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i
        omegaAll goals completed! 🐙
      ·e_a.hiI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)hn:i + 1 - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length =
  i - (List.takeWhile (fun b => decide ¬le1 r0 b) r).length + 1⊢ ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i) exact hrAll goals completed! 🐙
  ·hkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:↑(orderedInsertPos le1 r r0) ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i.succ simp only [orderedInsertPos] at hihkI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ii:ℕhi:(List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ ihr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.takeWhile (fun b => decide ¬le1 r0 b) r).length ≤ i.succ
    omegaAll goals completed! 🐙

The equivalence between Fin (r0 :: r).length and Fin (List.orderedInsert le1 r0 r).length according to where the elements map, i.e. 0 is taken to orderedInsertPos le1 r r0.

@[`@[expose]` has no effect outside a `module` fileexpose]
def orderedInsertEquiv {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I) (r0 : I) :
    Fin (r.length + 1) ≃ Fin (List.orderedInsert le1 r0 r).length := byn:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ Fin (r.length + 1) ≃ Fin (List.orderedInsert le1 r0 r).length
  let e2 : Fin (List.orderedInsert le1 r0 r).length ≃ Fin (r0 :: r).length :=
    (Fin.castOrderIso (List.orderedInsert_length le1 r r0)).toEquivn:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ie2:Fin (List.orderedInsert le1 r0 r).length ≃ Fin (r0 :: r).length := (Fin.castOrderIso ⋯).toEquiv⊢ Fin (r.length + 1) ≃ Fin (List.orderedInsert le1 r0 r).length
  let e3 : Fin (r0 :: r).length ≃ Fin 1 ⊕ Fin (r).length := finExtractOne 0n:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ie2:Fin (List.orderedInsert le1 r0 r).length ≃ Fin (r0 :: r).length := (Fin.castOrderIso ⋯).toEquive3:Fin (r0 :: r).length ≃ Fin 1 ⊕ Fin r.length := finExtractOne 0⊢ Fin (r.length + 1) ≃ Fin (List.orderedInsert le1 r0 r).length
  let e4 : Fin (r0 :: r).length ≃ Fin 1 ⊕ Fin (r).length :=
    finExtractOne ⟨orderedInsertPos le1 r r0, orderedInsertPos_lt_length le1 r r0⟩n:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ie2:Fin (List.orderedInsert le1 r0 r).length ≃ Fin (r0 :: r).length := (Fin.castOrderIso ⋯).toEquive3:Fin (r0 :: r).length ≃ Fin 1 ⊕ Fin r.length := finExtractOne 0e4:Fin (r0 :: r).length ≃ Fin 1 ⊕ Fin r.length := finExtractOne ⟨↑(orderedInsertPos le1 r r0), ⋯⟩⊢ Fin (r.length + 1) ≃ Fin (List.orderedInsert le1 r0 r).length
  exact e3.trans (e4.symm.trans e2.symm)All goals completed! 🐙

              @[simp]
lemma orderedInsertEquiv_zero {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
    (r0 : I) : orderedInsertEquiv le1 r r0 0 = orderedInsertPos le1 r r0 := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (orderedInsertEquiv le1 r r0) 0 = orderedInsertPos le1 r r0
  simp [orderedInsertEquiv]All goals completed! 🐙

lemma orderedInsertEquiv_succ {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
    (r0 : I) (n : ℕ) (hn : Nat.succ n < (r0 :: r).length) :
    orderedInsertEquiv le1 r r0 ⟨Nat.succ n, hn⟩ =
    Fin.cast (List.orderedInsert_length le1 r r0).symm
    ((Fin.succAbove ⟨(orderedInsertPos le1 r r0), orderedInsertPos_lt_length le1 r r0⟩)
    ⟨n, Nat.succ_lt_succ_iff.mp hn⟩) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕhn:n.succ < (r0 :: r).length⊢ (orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩ = Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n, ⋯⟩)
  simp only [List.length_cons, orderedInsertEquiv, Nat.succ_eq_add_one, Equiv.trans_apply]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕhn:n.succ < (r0 :: r).length⊢ (Fin.castOrderIso ⋯).symm ((finExtractOne ⟨↑(orderedInsertPos le1 r r0), ⋯⟩).symm ((finExtractOne 0) ⟨n + 1, hn⟩)) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n, ⋯⟩)
  match r with
  | [] =>I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕhn:n.succ < [r0].length⊢ (Fin.castOrderIso ⋯).symm ((finExtractOne ⟨↑(orderedInsertPos le1 [] r0), ⋯⟩).symm ((finExtractOne 0) ⟨n + 1, hn⟩)) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 [] r0), ⋯⟩.succAbove ⟨n, ⋯⟩)
    simpAll goals completed! 🐙
  | r1 :: r =>I:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm
    ((finExtractOne ⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩).symm ((finExtractOne 0) ⟨n + 1, hn⟩)) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove ⟨n, ⋯⟩)
    simp only [List.length_cons]I:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm
    ((finExtractOne ⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩).symm ((finExtractOne 0) ⟨n + 1, hn⟩)) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove ⟨n, ⋯⟩)
    rw [finExtractOne_apply_neqI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm
    ((finExtractOne ⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩).symm (Sum.inr (predAboveI 0 ⟨n + 1, hn⟩))) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove ⟨n, ⋯⟩)hijI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ 0 ≠ ⟨n + 1, hn⟩I:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm
    ((finExtractOne ⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩).symm (Sum.inr (predAboveI 0 ⟨n + 1, hn⟩))) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove ⟨n, ⋯⟩)hijI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ 0 ≠ ⟨n + 1, hn⟩]I:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm
    ((finExtractOne ⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩).symm (Sum.inr (predAboveI 0 ⟨n + 1, hn⟩))) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove ⟨n, ⋯⟩)hijI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ 0 ≠ ⟨n + 1, hn⟩
    simp only [orderedInsertPos, decide_not, Nat.succ_eq_add_one,
      finExtractOne_symm_inr_apply]I:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm
    (⟨(List.takeWhile (fun b => !decide (le1 r0 b)) (r1 :: r)).length, ⋯⟩.succAbove (predAboveI 0 ⟨n + 1, hn⟩)) =
  Fin.cast ⋯ (⟨(List.takeWhile (fun b => !decide (le1 r0 b)) (r1 :: r)).length, ⋯⟩.succAbove ⟨n, ⋯⟩)hijI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ 0 ≠ ⟨n + 1, hn⟩
    rflhijI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:In:ℕr1:Ir:List Ihn:n.succ < (r0 :: r1 :: r).length⊢ 0 ≠ ⟨n + 1, hn⟩
    exact ne_of_beq_false rflAll goals completed! 🐙

lemma orderedInsertEquiv_fin_succ {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
    (r0 : I) (n : Fin r.length) :
    orderedInsertEquiv le1 r r0 n.succ = Fin.cast (List.orderedInsert_length le1 r r0).symm
    ((Fin.succAbove ⟨(orderedInsertPos le1 r r0), orderedInsertPos_lt_length le1 r r0⟩)
      ⟨n, n.isLt⟩) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.length⊢ (orderedInsertEquiv le1 r r0) n.succ = Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩)
  simp only [orderedInsertEquiv, Equiv.trans_apply]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.length⊢ (Fin.castOrderIso ⋯).symm ((finExtractOne ⟨↑(orderedInsertPos le1 r r0), ⋯⟩).symm ((finExtractOne 0) n.succ)) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩)
  match r with
  | [] =>I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin [].length⊢ (Fin.castOrderIso ⋯).symm ((finExtractOne ⟨↑(orderedInsertPos le1 [] r0), ⋯⟩).symm ((finExtractOne 0) n.succ)) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 [] r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩)
    simpAll goals completed! 🐙
  | r1 :: r =>I:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm ((finExtractOne ⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩).symm ((finExtractOne 0) n.succ)) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩)
    simp only [List.length_cons, Fin.eta]I:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm ((finExtractOne ⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩).symm ((finExtractOne 0) n.succ)) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove n)
    rw [finExtractOne_apply_neqI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm
    ((finExtractOne ⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩).symm (Sum.inr (predAboveI 0 n.succ))) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove n)hijI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ 0 ≠ n.succI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm
    ((finExtractOne ⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩).symm (Sum.inr (predAboveI 0 n.succ))) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove n)hijI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ 0 ≠ n.succ]I:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm
    ((finExtractOne ⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩).symm (Sum.inr (predAboveI 0 n.succ))) =
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove n)hijI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ 0 ≠ n.succ
    simp only [orderedInsertPos, decide_not, Nat.succ_eq_add_one,
      finExtractOne_symm_inr_apply]I:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ (Fin.castOrderIso ⋯).symm
    (⟨(List.takeWhile (fun b => !decide (le1 r0 b)) (r1 :: r)).length, ⋯⟩.succAbove (predAboveI 0 n.succ)) =
  Fin.cast ⋯ (⟨(List.takeWhile (fun b => !decide (le1 r0 b)) (r1 :: r)).length, ⋯⟩.succAbove n)hijI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ 0 ≠ n.succ
    rflhijI:Typele1:I → I → Propinst✝:DecidableRel le1r✝:List Ir0:Ir1:Ir:List In:Fin (r1 :: r).length⊢ 0 ≠ n.succ
    exact ne_of_beq_false rflAll goals completed! 🐙

lemma orderedInsertEquiv_monotone_fin_succ {I : Type}
    (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
    (r0 : I) (n m : Fin r.length)
    (hx : orderedInsertEquiv le1 r r0 n.succ < orderedInsertEquiv le1 r r0 m.succ) :
    n < m := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:(orderedInsertEquiv le1 r r0) n.succ < (orderedInsertEquiv le1 r r0) m.succ⊢ n < m
  rw [orderedInsertEquiv_fin_succ,I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩) < (orderedInsertEquiv le1 r r0) m.succ⊢ n < mI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩)) <
  ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑m, ⋯⟩))⊢ n < m orderedInsertEquiv_fin_succ,I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩) <
  Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑m, ⋯⟩)⊢ n < mI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩)) <
  ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑m, ⋯⟩))⊢ n < m Fin.lt_defI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩)) <
  ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑m, ⋯⟩))⊢ n < mI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩)) <
  ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑m, ⋯⟩))⊢ n < m] at hxI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑n, ⋯⟩)) <
  ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨↑m, ⋯⟩))⊢ n < m
  simp only [Fin.eta, Fin.val_cast, Fin.val_fin_lt] at hxI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove n < ⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove m⊢ n < m
  rwa [Fin.succAbove_lt_succAbove_iffI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:n < m⊢ n < m]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthm:Fin r.lengthhx:n < m⊢ n < m at hxlemma orderedInsertEquiv_congr {α : Type} {r : α → α → Prop} [DecidableRel r] (a : α)
    (l l' : List α) (h : l = l') :
    orderedInsertEquiv r l a = (Fin.castOrderIso (byn:ℕα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αl':List αh:l = l'⊢ l.length + 1 = l'.length + 1 simp [h]All goals completed! 🐙)).toEquiv.trans
    ((orderedInsertEquiv r l' a).trans (Fin.castOrderIso (byn:ℕα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αl':List αh:l = l'⊢ (List.orderedInsert r a l').length = (List.orderedInsert r a l).length simp [h]All goals completed! 🐙)).toEquiv) := byα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αl':List αh:l = l'⊢ orderedInsertEquiv r l a = (Fin.castOrderIso ⋯).trans ((orderedInsertEquiv r l' a).trans (Fin.castOrderIso ⋯).toEquiv)
  subst hα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ orderedInsertEquiv r l a = (Fin.castOrderIso ⋯).trans ((orderedInsertEquiv r l a).trans (Fin.castOrderIso ⋯).toEquiv)
  rflAll goals completed! 🐙

lemma get_eq_orderedInsertEquiv {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
    (r0 : I) :
    (r0 :: r).get = (List.orderedInsert le1 r0 r).get ∘ (orderedInsertEquiv le1 r r0) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (r0 :: r).get = (List.orderedInsert le1 r0 r).get ∘ ⇑(orderedInsertEquiv le1 r r0)
  funext xI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).length⊢ (r0 :: r).get x = ((List.orderedInsert le1 r0 r).get ∘ ⇑(orderedInsertEquiv le1 r r0)) x
  match x with
  | ⟨0, h⟩ =>I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthh:0 < (r0 :: r).length⊢ (r0 :: r).get ⟨0, h⟩ = ((List.orderedInsert le1 r0 r).get ∘ ⇑(orderedInsertEquiv le1 r r0)) ⟨0, h⟩
    simpAll goals completed! 🐙
  | ⟨Nat.succ n, h⟩ =>I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).length⊢ (r0 :: r).get ⟨n.succ, h⟩ = ((List.orderedInsert le1 r0 r).get ∘ ⇑(orderedInsertEquiv le1 r r0)) ⟨n.succ, h⟩
    simp only [List.length_cons, Nat.succ_eq_add_one, List.get_eq_getElem, List.getElem_cons_succ,
      Function.comp_apply]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).length⊢ r[n] = (List.orderedInsert le1 r0 r)[↑((orderedInsertEquiv le1 r r0) ⟨n + 1, h⟩)]
    rw [orderedInsertEquiv_succI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).length⊢ r[n] = (List.orderedInsert le1 r0 r)[↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n, ⋯⟩))]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).length⊢ r[n] = (List.orderedInsert le1 r0 r)[↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n, ⋯⟩))]]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).length⊢ r[n] = (List.orderedInsert le1 r0 r)[↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n, ⋯⟩))]
    simp only [Fin.succAbove, Fin.castSucc_mk, Fin.mk_lt_mk, Fin.succ_mk, Fin.val_cast]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).length⊢ r[n] = (List.orderedInsert le1 r0 r)[↑(if n < ↑(orderedInsertPos le1 r r0) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩)]
    by_cases hn : n < ↑(orderedInsertPos le1 r r0)posI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:n < ↑(orderedInsertPos le1 r r0)⊢ r[n] = (List.orderedInsert le1 r0 r)[↑(if n < ↑(orderedInsertPos le1 r r0) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩)]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)⊢ r[n] = (List.orderedInsert le1 r0 r)[↑(if n < ↑(orderedInsertPos le1 r r0) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩)]
    ·posI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:n < ↑(orderedInsertPos le1 r r0)⊢ r[n] = (List.orderedInsert le1 r0 r)[↑(if n < ↑(orderedInsertPos le1 r r0) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩)] simp [hn, orderedInsert_get_lt]All goals completed! 🐙
    ·negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)⊢ r[n] = (List.orderedInsert le1 r0 r)[↑(if n < ↑(orderedInsertPos le1 r r0) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩)] simp only [hn, ↓reduceIte, List.orderedInsert_eq_take_drop, decide_not]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)⊢ r[n] = (List.takeWhile (fun b => !decide (le1 r0 b)) r ++ r0 :: List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1]
      rw [List.getElem_appendnegI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)⊢ r[n] =
  if h' : n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length then
    (List.takeWhile (fun b => !decide (le1 r0 b)) r)[n + 1]
  else
    (r0 ::
        List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)⊢ r[n] =
  if h' : n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length then
    (List.takeWhile (fun b => !decide (le1 r0 b)) r)[n + 1]
  else
    (r0 ::
        List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)⊢ r[n] =
  if h' : n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length then
    (List.takeWhile (fun b => !decide (le1 r0 b)) r)[n + 1]
  else
    (r0 ::
        List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]
      have hn' : ¬ n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (r0 :: r).get = (List.orderedInsert le1 r0 r).get ∘ ⇑(orderedInsertEquiv le1 r r0)negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ r[n] =
  if h' : n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length then
    (List.takeWhile (fun b => !decide (le1 r0 b)) r)[n + 1]
  else
    (r0 ::
        List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]
        simp only [orderedInsertPos, decide_not, not_lt] at hnI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:(List.takeWhile (fun b => !decide (le1 r0 b)) r).length ≤ n⊢ ¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthnegI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ r[n] =
  if h' : n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length then
    (List.takeWhile (fun b => !decide (le1 r0 b)) r)[n + 1]
  else
    (r0 ::
        List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]
        omeganegI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ r[n] =
  if h' : n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length then
    (List.takeWhile (fun b => !decide (le1 r0 b)) r)[n + 1]
  else
    (r0 ::
        List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ r[n] =
  if h' : n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length then
    (List.takeWhile (fun b => !decide (le1 r0 b)) r)[n + 1]
  else
    (r0 ::
        List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]
      simp only [hn', ↓reduceDIte]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).length⊢ r[n] =
  (r0 ::
      List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]
      have hnn : n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
        (n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length) + 1 := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (r0 :: r).get = (List.orderedInsert le1 r0 r).get ∘ ⇑(orderedInsertEquiv le1 r r0)negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1⊢ r[n] =
  (r0 ::
      List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]
        simp only [orderedInsertPos, decide_not, not_lt] at hnI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhn:(List.takeWhile (fun b => !decide (le1 r0 b)) r).length ≤ n⊢ n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1⊢ r[n] =
  (r0 ::
      List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]
        omeganegI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1⊢ r[n] =
  (r0 ::
      List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1⊢ r[n] =
  (r0 ::
      List.dropWhile (fun b => !decide (le1 r0 b)) r)[n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]
      simp only [hnn, List.getElem_cons_succ]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1⊢ r[n] = (List.dropWhile (fun b => !decide (le1 r0 b)) r)[n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length]
      conv_rhs =>
        rw [List.IsSuffix.getElem (List.dropWhile_suffix fun b => !decide (le1 r0 b))]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1| r[r.length - (List.dropWhile (fun b => !decide (le1 r0 b)) r).length +
    (n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)]
      congrneg.e_iI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1⊢ n =
  r.length - (List.dropWhile (fun b => !decide (le1 r0 b)) r).length +
    (n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)
      have hr : r.length = (List.takeWhile (fun b => !decide (le1 r0 b)) r).length +
          (List.dropWhile (fun b => !decide (le1 r0 b)) r).length := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (r0 :: r).get = (List.orderedInsert le1 r0 r).get ∘ ⇑(orderedInsertEquiv le1 r r0)neg.e_iI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1hr:r.length =
  (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + (List.dropWhile (fun b => !decide (le1 r0 b)) r).length⊢ n =
  r.length - (List.dropWhile (fun b => !decide (le1 r0 b)) r).length +
    (n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)
        rw [← List.length_appendI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1⊢ r.length = (List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r).lengthI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1⊢ r.length = (List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r).lengthneg.e_iI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1hr:r.length =
  (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + (List.dropWhile (fun b => !decide (le1 r0 b)) r).length⊢ n =
  r.length - (List.dropWhile (fun b => !decide (le1 r0 b)) r).length +
    (n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1⊢ r.length = (List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) r).lengthneg.e_iI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1hr:r.length =
  (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + (List.dropWhile (fun b => !decide (le1 r0 b)) r).length⊢ n =
  r.length - (List.dropWhile (fun b => !decide (le1 r0 b)) r).length +
    (n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)
        congrI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1⊢ r = List.takeWhile (fun b => !decide (le1 r0 b)) r ++ List.dropWhile (fun b => !decide (le1 r0 b)) rneg.e_iI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1hr:r.length =
  (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + (List.dropWhile (fun b => !decide (le1 r0 b)) r).length⊢ n =
  r.length - (List.dropWhile (fun b => !decide (le1 r0 b)) r).length +
    (n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)
        exact Eq.symm (List.takeWhile_append_dropWhile)neg.e_iI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1hr:r.length =
  (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + (List.dropWhile (fun b => !decide (le1 r0 b)) r).length⊢ n =
  r.length - (List.dropWhile (fun b => !decide (le1 r0 b)) r).length +
    (n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)neg.e_iI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1hr:r.length =
  (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + (List.dropWhile (fun b => !decide (le1 r0 b)) r).length⊢ n =
  r.length - (List.dropWhile (fun b => !decide (le1 r0 b)) r).length +
    (n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)
      simp only [hr, add_tsub_cancel_right]neg.e_iI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (r0 :: r).lengthn:ℕh:n.succ < (r0 :: r).lengthhn:¬n < ↑(orderedInsertPos le1 r r0)hn':¬n + 1 < (List.takeWhile (fun b => !decide (le1 r0 b)) r).lengthhnn:n + 1 - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length =
  n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + 1hr:r.length =
  (List.takeWhile (fun b => !decide (le1 r0 b)) r).length + (List.dropWhile (fun b => !decide (le1 r0 b)) r).length⊢ n =
  (List.takeWhile (fun b => !decide (le1 r0 b)) r).length +
    (n - (List.takeWhile (fun b => !decide (le1 r0 b)) r).length)
      omegaAll goals completed! 🐙lemma orderedInsertEquiv_get {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I)
    (r0 : I) :
    (r0 :: r).get ∘ (orderedInsertEquiv le1 r r0).symm = (List.orderedInsert le1 r0 r).get := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (r0 :: r).get ∘ ⇑(orderedInsertEquiv le1 r r0).symm = (List.orderedInsert le1 r0 r).get
  funext xI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:Ix:Fin (List.orderedInsert le1 r0 r).length⊢ ((r0 :: r).get ∘ ⇑(orderedInsertEquiv le1 r r0).symm) x = (List.orderedInsert le1 r0 r).get x
  simp [get_eq_orderedInsertEquiv le1]All goals completed! 🐙lemma orderedInsert_eraseIdx_orderedInsertEquiv_zero
    {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I) (r0 : I) :
    (List.orderedInsert le1 r0 r).eraseIdx (orderedInsertEquiv le1 r r0 ⟨0, byn:ℕI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ 0 < r.length + 1 simpAll goals completed! 🐙⟩) = r := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨0, ⋯⟩) = r
  simp [orderedInsertEquiv]All goals completed! 🐙

lemma orderedInsert_eraseIdx_orderedInsertEquiv_succ
    {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I) (r0 : I) (n : ℕ)
    (hn : Nat.succ n < (r0 :: r).length)
    (hr : ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) :
    (List.orderedInsert le1 r0 r).eraseIdx (orderedInsertEquiv le1 r r0 ⟨Nat.succ n, hn⟩) =
    (List.orderedInsert le1 r0 (r.eraseIdx n)) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕhn:n.succ < (r0 :: r).lengthhr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
  List.orderedInsert le1 r0 (r.eraseIdx n)
  induction r with
  | nil =>nilI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕhn:n.succ < [r0].lengthhr:∀ (i j : Fin [].length), i < j → ¬le1 r0 ([].get j) → ¬le1 r0 ([].get i)⊢ (List.orderedInsert le1 r0 []).eraseIdx ↑((orderedInsertEquiv le1 [] r0) ⟨n.succ, hn⟩) =
  List.orderedInsert le1 r0 ([].eraseIdx n)
    simp at hnAll goals completed! 🐙
  | cons r1 r ih =>consI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx ↑((orderedInsertEquiv le1 (r1 :: r) r0) ⟨n.succ, hn⟩) =
  List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)
    rw [orderedInsertEquiv_succconsI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx
    ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove ⟨n, ⋯⟩)) =
  List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)consI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx
    ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove ⟨n, ⋯⟩)) =
  List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)]consI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx
    ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (r1 :: r) r0), ⋯⟩.succAbove ⟨n, ⋯⟩)) =
  List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)
    simp only [List.length_cons, Fin.succAbove,
      Fin.castSucc_mk, Fin.mk_lt_mk, Fin.succ_mk, Fin.val_cast]consI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx
    ↑(if n < ↑(orderedInsertPos le1 (r1 :: r) r0) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩) =
  List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)
    by_cases hn' : n < (orderedInsertPos le1 (r1 :: r) r0)posI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx
    ↑(if n < ↑(orderedInsertPos le1 (r1 :: r) r0) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩) =
  List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)negI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':¬n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx
    ↑(if n < ↑(orderedInsertPos le1 (r1 :: r) r0) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩) =
  List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)
    ·posI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx
    ↑(if n < ↑(orderedInsertPos le1 (r1 :: r) r0) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩) =
  List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n) simp only [hn', ↓reduceIte]posI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx n = List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)
      rw [orderedInsert_eraseIdx_lt_orderedInsertPos le1 (r1 :: r) r0 n hn' hrposI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n) = List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)All goals completed! 🐙]All goals completed! 🐙
    ·negI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':¬n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx
    ↑(if n < ↑(orderedInsertPos le1 (r1 :: r) r0) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩) =
  List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n) simp only [hn', ↓reduceIte]negI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':¬n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ (List.orderedInsert le1 r0 (r1 :: r)).eraseIdx (n + 1) = List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)
      rw [orderedInsert_eraseIdx_orderedInsertPos_le le1 (r1 :: r) r0 n _ hrnegI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':¬n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n) = List.orderedInsert le1 r0 ((r1 :: r).eraseIdx n)I:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':¬n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ ↑(orderedInsertPos le1 (r1 :: r) r0) ≤ nI:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':¬n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ ↑(orderedInsertPos le1 (r1 :: r) r0) ≤ n]I:Typele1:I → I → Propinst✝:DecidableRel le1r0:In:ℕr1:Ir:List Iih:∀ (hn : n.succ < (r0 :: r).length),
  (∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) →
    (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) ⟨n.succ, hn⟩) =
      List.orderedInsert le1 r0 (r.eraseIdx n)hn:n.succ < (r0 :: r1 :: r).lengthhr:∀ (i j : Fin (r1 :: r).length), i < j → ¬le1 r0 ((r1 :: r).get j) → ¬le1 r0 ((r1 :: r).get i)hn':¬n < ↑(orderedInsertPos le1 (r1 :: r) r0)⊢ ↑(orderedInsertPos le1 (r1 :: r) r0) ≤ n
      omegaAll goals completed! 🐙lemma orderedInsert_eraseIdx_orderedInsertEquiv_fin_succ
    {I : Type} (le1 : I → I → Prop) [DecidableRel le1] (r : List I) (r0 : I) (n : Fin r.length)
    (hr : ∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)) :
    (List.orderedInsert le1 r0 r).eraseIdx (orderedInsertEquiv le1 r r0 n.succ) =
    (List.orderedInsert le1 r0 (r.eraseIdx n)) := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:Fin r.lengthhr:∀ (i j : Fin r.length), i < j → ¬le1 r0 (r.get j) → ¬le1 r0 (r.get i)⊢ (List.orderedInsert le1 r0 r).eraseIdx ↑((orderedInsertEquiv le1 r r0) n.succ) =
  List.orderedInsert le1 r0 (r.eraseIdx ↑n)
  exact orderedInsert_eraseIdx_orderedInsertEquiv_succ le1 r r0 n.val (Nat.succ_lt_succ n.isLt) hrAll goals completed! 🐙

lemma orderedInsertEquiv_sigma {I : Type} {f : I → Type}
    (le1 : I → I → Prop) [DecidableRel le1] (l : List (Σ i, f i))
    (i : I) (a : f i) :
    (orderedInsertEquiv (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) =
    (Fin.castOrderIso (byn:ℕI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f i⊢ l.length + 1 = (List.map (fun i => i.fst) l).length + 1 simpAll goals completed! 🐙)).toEquiv.trans
    ((orderedInsertEquiv le1 (List.map (fun i => i.1) l) i).trans
    (Fin.castOrderIso (byn:ℕI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f i⊢ (List.orderedInsert le1 i (List.map (fun i => i.fst) l)).length =
  (List.orderedInsert (fun i j => le1 i.fst j.fst) ⟨i, a⟩ l).length simp [List.orderedInsert_length]All goals completed! 🐙)).toEquiv) := byI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f i⊢ orderedInsertEquiv (fun i j => le1 i.fst j.fst) l ⟨i, a⟩ =
  (Fin.castOrderIso ⋯).trans
    ((orderedInsertEquiv le1 (List.map (fun i => i.fst) l) i).trans (Fin.castOrderIso ⋯).toEquiv)
  ext xI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)⊢ ↑((orderedInsertEquiv (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) x) =
  ↑(((Fin.castOrderIso ⋯).trans
        ((orderedInsertEquiv le1 (List.map (fun i => i.fst) l) i).trans (Fin.castOrderIso ⋯).toEquiv))
      x)
  match x with
  | ⟨0, h0⟩ =>I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)h0:0 < l.length + 1⊢ ↑((orderedInsertEquiv (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) ⟨0, h0⟩) =
  ↑(((Fin.castOrderIso ⋯).trans
        ((orderedInsertEquiv le1 (List.map (fun i => i.fst) l) i).trans (Fin.castOrderIso ⋯).toEquiv))
      ⟨0, h0⟩)
    simp only [Fin.zero_eta, Equiv.trans_apply, RelIso.coe_fn_toEquiv, Fin.castOrderIso_apply,
      Fin.cast_zero, Fin.val_cast]I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)h0:0 < l.length + 1⊢ ↑((orderedInsertEquiv (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) 0) =
  ↑((orderedInsertEquiv le1 (List.map (fun i => i.fst) l) i) 0)
    rw [orderedInsertEquiv_zero,I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)h0:0 < l.length + 1⊢ ↑(orderedInsertPos (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) =
  ↑((orderedInsertEquiv le1 (List.map (fun i => i.fst) l) i) 0)I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)h0:0 < l.length + 1⊢ ↑(orderedInsertPos (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) = ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i) orderedInsertEquiv_zeroI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)h0:0 < l.length + 1⊢ ↑(orderedInsertPos (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) = ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i)I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)h0:0 < l.length + 1⊢ ↑(orderedInsertPos (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) = ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i)]I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)h0:0 < l.length + 1⊢ ↑(orderedInsertPos (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) = ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i)
    simp [orderedInsertPos_sigma]All goals completed! 🐙
  | ⟨Nat.succ n, h0⟩ =>I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑((orderedInsertEquiv (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) ⟨n.succ, h0⟩) =
  ↑(((Fin.castOrderIso ⋯).trans
        ((orderedInsertEquiv le1 (List.map (fun i => i.fst) l) i).trans (Fin.castOrderIso ⋯).toEquiv))
      ⟨n.succ, h0⟩)
    simp only [Nat.succ_eq_add_one, Equiv.trans_apply, RelIso.coe_fn_toEquiv,
      Fin.castOrderIso_apply, Fin.cast_mk, Fin.val_cast]I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑((orderedInsertEquiv (fun i j => le1 i.fst j.fst) l ⟨i, a⟩) ⟨n + 1, h0⟩) =
  ↑((orderedInsertEquiv le1 (List.map (fun i => i.fst) l) i) ⟨n + 1, ⋯⟩)
    erw [orderedInsertEquiv_succ,I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos (fun i j => le1 i.fst j.fst) l ⟨i, a⟩), ⋯⟩.succAbove ⟨n, ⋯⟩)) =
  ↑((orderedInsertEquiv le1 (List.map (fun i => i.fst) l) i) ⟨n + 1, ⋯⟩) orderedInsertEquiv_succI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos (fun i j => le1 i.fst j.fst) l ⟨i, a⟩), ⋯⟩.succAbove ⟨n, ⋯⟩)) =
  ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩.succAbove ⟨n, ⋯⟩))]I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos (fun i j => le1 i.fst j.fst) l ⟨i, a⟩), ⋯⟩.succAbove ⟨n, ⋯⟩)) =
  ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩.succAbove ⟨n, ⋯⟩))
    simp only [orderedInsertPos_sigma, Fin.val_cast]I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑(⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩.succAbove ⟨n, ⋯⟩) =
  ↑(⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩.succAbove ⟨n, ⋯⟩)
    rw [Fin.succAbove,I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑(if ⟨n, ⋯⟩.castSucc < ⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩ then ⟨n, ⋯⟩.castSucc
    else ⟨n, ⋯⟩.succ) =
  ↑(⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩.succAbove ⟨n, ⋯⟩)I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑(if ⟨n, ⋯⟩.castSucc < ⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩ then ⟨n, ⋯⟩.castSucc
    else ⟨n, ⋯⟩.succ) =
  ↑(if ⟨n, ⋯⟩.castSucc < ⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩ then ⟨n, ⋯⟩.castSucc
    else ⟨n, ⋯⟩.succ) Fin.succAboveI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑(if ⟨n, ⋯⟩.castSucc < ⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩ then ⟨n, ⋯⟩.castSucc
    else ⟨n, ⋯⟩.succ) =
  ↑(if ⟨n, ⋯⟩.castSucc < ⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩ then ⟨n, ⋯⟩.castSucc
    else ⟨n, ⋯⟩.succ)I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑(if ⟨n, ⋯⟩.castSucc < ⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩ then ⟨n, ⋯⟩.castSucc
    else ⟨n, ⋯⟩.succ) =
  ↑(if ⟨n, ⋯⟩.castSucc < ⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩ then ⟨n, ⋯⟩.castSucc
    else ⟨n, ⋯⟩.succ)]I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑(if ⟨n, ⋯⟩.castSucc < ⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩ then ⟨n, ⋯⟩.castSucc
    else ⟨n, ⋯⟩.succ) =
  ↑(if ⟨n, ⋯⟩.castSucc < ⟨↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i), ⋯⟩ then ⟨n, ⋯⟩.castSucc
    else ⟨n, ⋯⟩.succ)
    simp only [Fin.castSucc_mk, Fin.mk_lt_mk, Fin.succ_mk]I:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1⊢ ↑(if n < ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩) =
  ↑(if n < ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i) then ⟨n, ⋯⟩ else ⟨n + 1, ⋯⟩)
    splitisTrueI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1h✝:n < ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i)⊢ ↑⟨n, ⋯⟩ = ↑⟨n, ⋯⟩isFalseI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1h✝:¬n < ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i)⊢ ↑⟨n + 1, ⋯⟩ = ↑⟨n + 1, ⋯⟩ <;>isTrueI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1h✝:n < ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i)⊢ ↑⟨n, ⋯⟩ = ↑⟨n, ⋯⟩isFalseI:Typef:I → Typele1:I → I → Propinst✝:DecidableRel le1l:List ((i : I) × f i)i:Ia:f ix:Fin (l.length + 1)n:ℕh0:n.succ < l.length + 1h✝:¬n < ↑(orderedInsertPos le1 (List.map (fun i => i.fst) l) i)⊢ ↑⟨n + 1, ⋯⟩ = ↑⟨n + 1, ⋯⟩ rflAll goals completed! 🐙set_option maxHeartbeats 350000
lemma orderedInsert_eq_insertIdx_orderedInsertPos {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    (r : List I) (r0 : I) :
    List.orderedInsert le1 r0 r = List.insertIdx r (orderedInsertPos le1 r r0).1 r0 := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.orderedInsert le1 r0 r = r.insertIdx (↑(orderedInsertPos le1 r r0)) r0
  apply List.ext_gethlI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.orderedInsert le1 r0 r).length = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ ∀ (n : ℕ) (h₁ : n < (List.orderedInsert le1 r0 r).length)
  (h₂ : n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).length),
  (List.orderedInsert le1 r0 r).get ⟨n, h₁⟩ = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨n, h₂⟩
  ·hlI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ (List.orderedInsert le1 r0 r).length = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).length simp only [List.orderedInsert_length]hlI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ r.length + 1 = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).length
    rw [List.length_insertIdxhlI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ r.length + 1 = if ↑(orderedInsertPos le1 r r0) ≤ r.length then r.length + 1 else r.lengthhlI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ r.length + 1 = if ↑(orderedInsertPos le1 r r0) ≤ r.length then r.length + 1 else r.length]hlI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ r.length + 1 = if ↑(orderedInsertPos le1 r r0) ≤ r.length then r.length + 1 else r.length
    exact (if_pos (Nat.le_of_succ_le_succ (orderedInsertPos_lt_length le1 r r0))).symmAll goals completed! 🐙
  intro n h1 h2hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.orderedInsert le1 r0 r).lengthh2:n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).length⊢ (List.orderedInsert le1 r0 r).get ⟨n, h1⟩ = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨n, h2⟩
  obtain ⟨n', hn'⟩ := (orderedInsertEquiv le1 r r0).surjective ⟨n, h1⟩hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.orderedInsert le1 r0 r).lengthh2:n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthn':Fin (r.length + 1)hn':(orderedInsertEquiv le1 r r0) n' = ⟨n, h1⟩⊢ (List.orderedInsert le1 r0 r).get ⟨n, h1⟩ = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨n, h2⟩
  rw [← hn'hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.orderedInsert le1 r0 r).lengthh2:n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthn':Fin (r.length + 1)hn':(orderedInsertEquiv le1 r r0) n' = ⟨n, h1⟩⊢ (List.orderedInsert le1 r0 r).get ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨n, h2⟩hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.orderedInsert le1 r0 r).lengthh2:n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthn':Fin (r.length + 1)hn':(orderedInsertEquiv le1 r r0) n' = ⟨n, h1⟩⊢ (List.orderedInsert le1 r0 r).get ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨n, h2⟩]hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.orderedInsert le1 r0 r).lengthh2:n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthn':Fin (r.length + 1)hn':(orderedInsertEquiv le1 r r0) n' = ⟨n, h1⟩⊢ (List.orderedInsert le1 r0 r).get ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨n, h2⟩
  have hn'' : n = ((orderedInsertEquiv le1 r r0) n').val := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.orderedInsert le1 r0 r = r.insertIdx (↑(orderedInsertPos le1 r r0)) r0hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.orderedInsert le1 r0 r).lengthh2:n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthn':Fin (r.length + 1)hn':(orderedInsertEquiv le1 r r0) n' = ⟨n, h1⟩hn'':n = ↑((orderedInsertEquiv le1 r r0) n')⊢ (List.orderedInsert le1 r0 r).get ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨n, h2⟩ rw [hn'I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.orderedInsert le1 r0 r).lengthh2:n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthn':Fin (r.length + 1)hn':(orderedInsertEquiv le1 r r0) n' = ⟨n, h1⟩⊢ n = ↑⟨n, h1⟩hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.orderedInsert le1 r0 r).lengthh2:n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthn':Fin (r.length + 1)hn':(orderedInsertEquiv le1 r r0) n' = ⟨n, h1⟩hn'':n = ↑((orderedInsertEquiv le1 r r0) n')⊢ (List.orderedInsert le1 r0 r).get ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨n, h2⟩]hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.orderedInsert le1 r0 r).lengthh2:n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthn':Fin (r.length + 1)hn':(orderedInsertEquiv le1 r r0) n' = ⟨n, h1⟩hn'':n = ↑((orderedInsertEquiv le1 r r0) n')⊢ (List.orderedInsert le1 r0 r).get ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨n, h2⟩hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In:ℕh1:n < (List.orderedInsert le1 r0 r).lengthh2:n < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthn':Fin (r.length + 1)hn':(orderedInsertEquiv le1 r r0) n' = ⟨n, h1⟩hn'':n = ↑((orderedInsertEquiv le1 r r0) n')⊢ (List.orderedInsert le1 r0 r).get ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨n, h2⟩
  subst hn''hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In':Fin (r.length + 1)h1:↑((orderedInsertEquiv le1 r r0) n') < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) n') < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) n' = ⟨↑((orderedInsertEquiv le1 r r0) n'), h1⟩⊢ (List.orderedInsert le1 r0 r).get ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) n'), h2⟩
  rw [← orderedInsertEquiv_gethI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In':Fin (r.length + 1)h1:↑((orderedInsertEquiv le1 r r0) n') < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) n') < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) n' = ⟨↑((orderedInsertEquiv le1 r r0) n'), h1⟩⊢ ((r0 :: r).get ∘ ⇑(orderedInsertEquiv le1 r r0).symm) ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) n'), h2⟩hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In':Fin (r.length + 1)h1:↑((orderedInsertEquiv le1 r r0) n') < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) n') < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) n' = ⟨↑((orderedInsertEquiv le1 r r0) n'), h1⟩⊢ ((r0 :: r).get ∘ ⇑(orderedInsertEquiv le1 r r0).symm) ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) n'), h2⟩]hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In':Fin (r.length + 1)h1:↑((orderedInsertEquiv le1 r r0) n') < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) n') < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) n' = ⟨↑((orderedInsertEquiv le1 r r0) n'), h1⟩⊢ ((r0 :: r).get ∘ ⇑(orderedInsertEquiv le1 r r0).symm) ((orderedInsertEquiv le1 r r0) n') =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) n'), h2⟩
  simp only [List.length_cons, Function.comp_apply, Equiv.symm_apply_apply, List.get_eq_getElem]hI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In':Fin (r.length + 1)h1:↑((orderedInsertEquiv le1 r r0) n') < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) n') < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) n' = ⟨↑((orderedInsertEquiv le1 r r0) n'), h1⟩⊢ (r0 :: r)[↑n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑((orderedInsertEquiv le1 r r0) n')]
  match n' with
  | ⟨0, h0⟩ =>I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In':Fin (r.length + 1)h0:0 < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨0, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨0, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨0, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨0, h0⟩), h1⟩⊢ (r0 :: r)[↑⟨0, h0⟩] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑((orderedInsertEquiv le1 r r0) ⟨0, h0⟩)]
    simp only [List.getElem_cons_zero, Fin.zero_eta, orderedInsertEquiv_zero,
      List.getElem_insertIdx_self]All goals completed! 🐙
  | ⟨Nat.succ n', h0⟩ =>I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩⊢ (r0 :: r)[↑⟨n'.succ, h0⟩] =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩)]
    simp only [Nat.succ_eq_add_one, List.getElem_cons_succ]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩)]
    have hr := orderedInsertEquiv_succ le1 r r0 n' h0I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩)⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩)]
    trans (List.insertIdx r (↑(orderedInsertPos le1 r r0)) r0).get
      ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' +1, h0⟩), h2⟩I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩)⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩)⊢ (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩)]
    swapI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩)⊢ (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩)]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩)⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩
    ·I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩)⊢ (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩)] rflAll goals completed! 🐙
    rw [Fin.ext_iffI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩] at hrI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩
    have hx : (⟨↑((orderedInsertEquiv le1 r r0) ⟨n' +1, h0⟩), h2⟩ :
        Fin (List.insertIdx r (↑(orderedInsertPos le1 r r0)) r0).length) =
      ⟨((⟨↑(orderedInsertPos le1 r r0),
      orderedInsertPos_lt_length le1 r r0⟩ : Fin ((r).length + 1))).succAbove
      ⟨n', Nat.succ_lt_succ_iff.mp h0⟩, byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))⊢ ↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩
          erw [← hrI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))⊢ ↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))⊢ ↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩
          exact h2All goals completed! 🐙I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩⟩ := byI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:I⊢ List.orderedInsert le1 r0 r = r.insertIdx (↑(orderedInsertPos le1 r r0)) r0I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩
      rw [Fin.ext_iffI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))⊢ ↑⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ↑⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))⊢ ↑⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ↑⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))⊢ ↑⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ↑⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩
      simp onlyI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))⊢ ↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩) = ↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩)I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩
      simpa using hrI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩
    rw [hxI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).get ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩
    simp only [Fin.succAbove, Fin.castSucc_mk, Fin.mk_lt_mk, Fin.succ_mk, List.get_eq_getElem]I:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn':(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩⊢ r[n'] =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑(if n' < ↑(orderedInsertPos le1 r r0) then ⟨n', ⋯⟩ else ⟨n' + 1, ⋯⟩)]
    by_cases hn' : n' < ↑(orderedInsertPos le1 r r0)posI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑(if n' < ↑(orderedInsertPos le1 r r0) then ⟨n', ⋯⟩ else ⟨n' + 1, ⋯⟩)]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑(if n' < ↑(orderedInsertPos le1 r r0) then ⟨n', ⋯⟩ else ⟨n' + 1, ⋯⟩)]
    ·posI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑(if n' < ↑(orderedInsertPos le1 r r0) then ⟨n', ⋯⟩ else ⟨n' + 1, ⋯⟩)] simp only [hn', ↓reduceIte]posI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[n']
      erw [List.getElem_insertIdx_of_ltposI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] = r[n']pos.hnI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':n' < ↑(orderedInsertPos le1 r r0)⊢ n' < ↑(orderedInsertPos le1 r r0)]pos.hnI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':n' < ↑(orderedInsertPos le1 r r0)⊢ n' < ↑(orderedInsertPos le1 r r0)
      exact hn'All goals completed! 🐙
    ·negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] =
  (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[↑(if n' < ↑(orderedInsertPos le1 r r0) then ⟨n', ⋯⟩ else ⟨n' + 1, ⋯⟩)] simp only [hn', ↓reduceIte]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] = (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0)[n' + 1]
      rw [List.getElem_insertIdx_of_gtnegI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] = r[n' + 1 - 1]neg.hnI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ ↑(orderedInsertPos le1 r r0) < n' + 1negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] = r[n' + 1 - 1]neg.hnI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ ↑(orderedInsertPos le1 r r0) < n' + 1]negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] = r[n' + 1 - 1]neg.hnI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ ↑(orderedInsertPos le1 r r0) < n' + 1
      ·negI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ r[n'] = r[n' + 1 - 1] rflAll goals completed! 🐙
      ·neg.hnI:Typele1:I → I → Propinst✝:DecidableRel le1r:List Ir0:In'✝:Fin (r.length + 1)n':ℕh0:n'.succ < r.length + 1h1:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (List.orderedInsert le1 r0 r).lengthh2:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) < (r.insertIdx (↑(orderedInsertPos le1 r r0)) r0).lengthhn'✝:(orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩ = ⟨↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩), h1⟩hr:↑((orderedInsertEquiv le1 r r0) ⟨n'.succ, h0⟩) = ↑(Fin.cast ⋯ (⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩))hx:⟨↑((orderedInsertEquiv le1 r r0) ⟨n' + 1, h0⟩), h2⟩ = ⟨↑(⟨↑(orderedInsertPos le1 r r0), ⋯⟩.succAbove ⟨n', ⋯⟩), ⋯⟩hn':¬n' < ↑(orderedInsertPos le1 r r0)⊢ ↑(orderedInsertPos le1 r r0) < n' + 1 omegaAll goals completed! 🐙

The equivalence between Fin l.length ≃ Fin (List.insertionSort r l).length induced by the sorting algorithm.

def insertionSortEquiv {α : Type} (r : α → α → Prop) [DecidableRel r] : (l : List α) →
    Fin l.length ≃ Fin (List.insertionSort r l).length
  | [] => Equiv.refl _
  | a :: l =>
    (Fin.equivCons (insertionSortEquiv r l)).trans (orderedInsertEquiv r (List.insertionSort r l) a)

              

lemma insertionSortEquiv_get {α : Type} {r : α → α → Prop} [DecidableRel r] : (l : List α) →
    l.get ∘ (insertionSortEquiv r l).symm = (List.insertionSort r l).get
  | [] =>α:Typer:α → α → Propinst✝:DecidableRel r⊢ [].get ∘ ⇑(insertionSortEquiv r []).symm = (List.insertionSort r []).get byα:Typer:α → α → Propinst✝:DecidableRel r⊢ [].get ∘ ⇑(insertionSortEquiv r []).symm = (List.insertionSort r []).get rflAll goals completed! 🐙
  | a :: l =>α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (a :: l).get ∘ ⇑(insertionSortEquiv r (a :: l)).symm = (List.insertionSort r (a :: l)).get byα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (a :: l).get ∘ ⇑(insertionSortEquiv r (a :: l)).symm = (List.insertionSort r (a :: l)).get
    rw [insertionSortEquivα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (a :: l).get ∘ ⇑((equivCons (insertionSortEquiv r l)).trans (orderedInsertEquiv r (List.insertionSort r l) a)).symm =
  (List.insertionSort r (a :: l)).getα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (a :: l).get ∘ ⇑((equivCons (insertionSortEquiv r l)).trans (orderedInsertEquiv r (List.insertionSort r l) a)).symm =
  (List.insertionSort r (a :: l)).get]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (a :: l).get ∘ ⇑((equivCons (insertionSortEquiv r l)).trans (orderedInsertEquiv r (List.insertionSort r l) a)).symm =
  (List.insertionSort r (a :: l)).get
    change ((a :: l).get ∘ ((Fin.equivCons (insertionSortEquiv r l))).symm) ∘
      (orderedInsertEquiv r (List.insertionSort r l) a).symm = _α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).get
    have hl : (a :: l).get ∘ ((Fin.equivCons (insertionSortEquiv r l))).symm =
        (a :: List.insertionSort r l).get := byα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List α⊢ (a :: l).get ∘ ⇑(insertionSortEquiv r (a :: l)).symm = (List.insertionSort r (a :: l)).getα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).get
      ext xα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αx:Fin (List.insertionSort r l).length.succ⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) x = (a :: List.insertionSort r l).get xα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).get
      match x with
      | ⟨0, h⟩ =>α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αx:Fin (List.insertionSort r l).length.succh:0 < (List.insertionSort r l).length.succ⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ⟨0, h⟩ = (a :: List.insertionSort r l).get ⟨0, h⟩α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).get rflAll goals completed! 🐙α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).get
      | ⟨Nat.succ x, h⟩ =>α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αx✝:Fin (List.insertionSort r l).length.succx:ℕh:x.succ < (List.insertionSort r l).length.succ⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ⟨x.succ, h⟩ = (a :: List.insertionSort r l).get ⟨x.succ, h⟩α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).get
        change _ = (List.insertionSort r l).get _α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αx✝:Fin (List.insertionSort r l).length.succx:ℕh:x.succ < (List.insertionSort r l).length.succ⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ⟨x.succ, h⟩ = (List.insertionSort r l).get ⟨x, ⋯⟩α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).get
        rw [← insertionSortEquiv_get (r := r) lα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αx✝:Fin (List.insertionSort r l).length.succx:ℕh:x.succ < (List.insertionSort r l).length.succ⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ⟨x.succ, h⟩ =
  (l.get ∘ ⇑(insertionSortEquiv r l).symm) ⟨x, ⋯⟩α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αx✝:Fin (List.insertionSort r l).length.succx:ℕh:x.succ < (List.insertionSort r l).length.succ⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ⟨x.succ, h⟩ =
  (l.get ∘ ⇑(insertionSortEquiv r l).symm) ⟨x, ⋯⟩α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).get]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αx✝:Fin (List.insertionSort r l).length.succx:ℕh:x.succ < (List.insertionSort r l).length.succ⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ⟨x.succ, h⟩ =
  (l.get ∘ ⇑(insertionSortEquiv r l).symm) ⟨x, ⋯⟩α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).get
        rflα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).getα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ ((a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm) ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).get
    rw [hl,α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ (a :: List.insertionSort r l).get ∘ ⇑(orderedInsertEquiv r (List.insertionSort r l) a).symm =
  (List.insertionSort r (a :: l)).getα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ (List.orderedInsert r a (List.insertionSort r l)).get = (List.insertionSort r (a :: l)).get orderedInsertEquiv_get r (List.insertionSort r l) aα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ (List.orderedInsert r a (List.insertionSort r l)).get = (List.insertionSort r (a :: l)).getα:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ (List.orderedInsert r a (List.insertionSort r l)).get = (List.insertionSort r (a :: l)).get]α:Typer:α → α → Propinst✝:DecidableRel ra:αl:List αhl:(a :: l).get ∘ ⇑(equivCons (insertionSortEquiv r l)).symm = (a :: List.insertionSort r l).get⊢ (List.orderedInsert r a (List.insertionSort r l)).get = (List.insertionSort r (a :: l)).get
    rflAll goals completed! 🐙lemma insertionSortEquiv_congr {α : Type} {r : α → α → Prop} [DecidableRel r] (l l' : List α)
    (h : l = l') : insertionSortEquiv r l = (Fin.castOrderIso (byn:ℕα:Typer:α → α → Propinst✝:DecidableRel rl:List αl':List αh:l = l'⊢ l.length = l'.length simp [h]All goals completed! 🐙)).toEquiv.trans
      ((insertionSortEquiv r l').trans (Fin.castOrderIso (byn:ℕα:Typer:α → α → Propinst✝:DecidableRel rl:List αl':List αh:l = l'⊢ (List.insertionSort r l').length = (List.insertionSort r l).length simp [h]All goals completed! 🐙)).toEquiv) := byα:Typer:α → α → Propinst✝:DecidableRel rl:List αl':List αh:l = l'⊢ insertionSortEquiv r l = (Fin.castOrderIso ⋯).trans ((insertionSortEquiv r l').trans (Fin.castOrderIso ⋯).toEquiv)
  subst hα:Typer:α → α → Propinst✝:DecidableRel rl:List α⊢ insertionSortEquiv r l = (Fin.castOrderIso ⋯).trans ((insertionSortEquiv r l).trans (Fin.castOrderIso ⋯).toEquiv)
  rflAll goals completed! 🐙

lemma insertionSortEquiv_congr_apply {α : Type} {r : α → α → Prop} [DecidableRel r] (l l' : List α)
    (h : l = l') (i : Fin l.length) :
    insertionSortEquiv r l i =
    Fin.cast (byn:ℕα:Typer:α → α → Propinst✝:DecidableRel rl:List αl':List αh:l = l'i:Fin l.length⊢ (List.insertionSort r l').length = (List.insertionSort r l).length simp [h]All goals completed! 🐙)
    ((insertionSortEquiv r l') (Fin.cast (byn:ℕα:Typer:α → α → Propinst✝:DecidableRel rl:List αl':List αh:l = l'i:Fin l.length⊢ l.length = l'.length simp [h]All goals completed! 🐙) i)) := byα:Typer:α → α → Propinst✝:DecidableRel rl:List αl':List αh:l = l'i:Fin l.length⊢ (insertionSortEquiv r l) i = Fin.cast ⋯ ((insertionSortEquiv r l') (Fin.cast ⋯ i))
  rw [insertionSortEquiv_congr l l' hα:Typer:α → α → Propinst✝:DecidableRel rl:List αl':List αh:l = l'i:Fin l.length⊢ ((Fin.castOrderIso ⋯).trans ((insertionSortEquiv r l').trans (Fin.castOrderIso ⋯).toEquiv)) i =
  Fin.cast ⋯ ((insertionSortEquiv r l') (Fin.cast ⋯ i))α:Typer:α → α → Propinst✝:DecidableRel rl:List αl':List αh:l = l'i:Fin l.length⊢ ((Fin.castOrderIso ⋯).trans ((insertionSortEquiv r l').trans (Fin.castOrderIso ⋯).toEquiv)) i =
  Fin.cast ⋯ ((insertionSortEquiv r l') (Fin.cast ⋯ i))]α:Typer:α → α → Propinst✝:DecidableRel rl:List αl':List αh:l = l'i:Fin l.length⊢ ((Fin.castOrderIso ⋯).trans ((insertionSortEquiv r l').trans (Fin.castOrderIso ⋯).toEquiv)) i =
  Fin.cast ⋯ ((insertionSortEquiv r l') (Fin.cast ⋯ i))
  simpAll goals completed! 🐙lemma insertionSort_get_comp_insertionSortEquiv {α : Type} {r : α → α → Prop} [DecidableRel r]
    (l : List α) : (List.insertionSort r l).get ∘ (insertionSortEquiv r l) = l.get := byα:Typer:α → α → Propinst✝:DecidableRel rl:List α⊢ (List.insertionSort r l).get ∘ ⇑(insertionSortEquiv r l) = l.get
  funext xα:Typer:α → α → Propinst✝:DecidableRel rl:List αx:Fin l.length⊢ ((List.insertionSort r l).get ∘ ⇑(insertionSortEquiv r l)) x = l.get x
  simp [← insertionSortEquiv_get]All goals completed! 🐙

lemma insertionSort_eq_ofFn {α : Type} {r : α → α → Prop} [DecidableRel r] (l : List α) :
    List.insertionSort r l = List.ofFn (l.get ∘ (insertionSortEquiv r l).symm) := byα:Typer:α → α → Propinst✝:DecidableRel rl:List α⊢ List.insertionSort r l = List.ofFn (l.get ∘ ⇑(insertionSortEquiv r l).symm)
  rw [insertionSortEquiv_get (r := r),α:Typer:α → α → Propinst✝:DecidableRel rl:List α⊢ List.insertionSort r l = List.ofFn (List.insertionSort r l).getAll goals completed! 🐙 List.ofFn_getα:Typer:α → α → Propinst✝:DecidableRel rl:List α⊢ List.insertionSort r l = List.insertionSort r lAll goals completed! 🐙]All goals completed! 🐙

lemma insertionSortEquiv_order {α : Type} {r : α → α → Prop} [DecidableRel r] :
    (l : List α) → (i : Fin l.length) → (j : Fin l.length) → (hij : i < j)
    → (hij' : insertionSortEquiv r l j < insertionSortEquiv r l i) →
    ¬ r l[i] l[j]
  | [], i, _, _, _ => Fin.elim0 i
  | a :: as, ⟨0, hi⟩, ⟨j + 1, hj⟩, hij, hij' =>α:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αhi:0 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨0, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (insertionSortEquiv r (a :: as)) ⟨0, hi⟩⊢ ¬r (a :: as)[⟨0, hi⟩] (a :: as)[⟨j + 1, hj⟩] byα:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αhi:0 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨0, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (insertionSortEquiv r (a :: as)) ⟨0, hi⟩⊢ ¬r (a :: as)[⟨0, hi⟩] (a :: as)[⟨j + 1, hj⟩]
    simp only [List.length_cons, Fin.zero_eta, Fin.getElem_fin, Fin.val_zero,
      List.getElem_cons_zero, List.getElem_cons_succ]α:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αhi:0 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨0, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (insertionSortEquiv r (a :: as)) ⟨0, hi⟩⊢ ¬r a as[j]
    nth_rewrite 2 [insertionSortEquiv] at hij'α:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αhi:0 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨0, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ <
  ((equivCons (insertionSortEquiv r as)).trans (orderedInsertEquiv r (List.insertionSort r as) a)) ⟨0, hi⟩⊢ ¬r a as[j]
    simp only [List.length_cons, Nat.succ_eq_add_one, Fin.zero_eta,
      Equiv.trans_apply, equivCons_zero] at hij'α:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αhi:0 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨0, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (orderedInsertEquiv r (List.insertionSort r as) a) 0⊢ ¬r a as[j]
    convert lt_orderedInsertPos_rel_fin r a (List.insertionSort r as) _ hij'α:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αhi:0 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨0, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (orderedInsertEquiv r (List.insertionSort r as) a) 0⊢ as[j] = (List.orderedInsert r a (List.insertionSort r as)).get ((insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩)
    change _ = ((List.insertionSort r (a :: as))).get ((insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩)α:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αhi:0 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨0, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (orderedInsertEquiv r (List.insertionSort r as) a) 0⊢ as[j] = (List.insertionSort r (a :: as)).get ((insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩)
    rw [← insertionSortEquiv_getα:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αhi:0 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨0, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (orderedInsertEquiv r (List.insertionSort r as) a) 0⊢ as[j] = ((a :: as).get ∘ ⇑(insertionSortEquiv r (a :: as)).symm) ((insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩)α:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αhi:0 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨0, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (orderedInsertEquiv r (List.insertionSort r as) a) 0⊢ as[j] = ((a :: as).get ∘ ⇑(insertionSortEquiv r (a :: as)).symm) ((insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩)]α:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αhi:0 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨0, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (orderedInsertEquiv r (List.insertionSort r as) a) 0⊢ as[j] = ((a :: as).get ∘ ⇑(insertionSortEquiv r (a :: as)).symm) ((insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩)
    simpAll goals completed! 🐙
  | a :: as, ⟨i + 1, hi⟩, ⟨j + 1, hj⟩, hij, hij' =>α:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αi:ℕhi:i + 1 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨i + 1, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (insertionSortEquiv r (a :: as)) ⟨i + 1, hi⟩⊢ ¬r (a :: as)[⟨i + 1, hi⟩] (a :: as)[⟨j + 1, hj⟩] byα:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αi:ℕhi:i + 1 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨i + 1, hi⟩ < ⟨j + 1, hj⟩hij':(insertionSortEquiv r (a :: as)) ⟨j + 1, hj⟩ < (insertionSortEquiv r (a :: as)) ⟨i + 1, hi⟩⊢ ¬r (a :: as)[⟨i + 1, hi⟩] (a :: as)[⟨j + 1, hj⟩]
    simp only [List.length_cons, insertionSortEquiv, Nat.succ_eq_add_one, Equiv.trans_apply,
      equivCons_succ] at hij'α:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αi:ℕhi:i + 1 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨i + 1, hi⟩ < ⟨j + 1, hj⟩hij':(orderedInsertEquiv r (List.insertionSort r as) a) ((insertionSortEquiv r as) ⟨j, ⋯⟩).succ <
  (orderedInsertEquiv r (List.insertionSort r as) a) ((insertionSortEquiv r as) ⟨i, ⋯⟩).succ⊢ ¬r (a :: as)[⟨i + 1, hi⟩] (a :: as)[⟨j + 1, hj⟩]
    simpa using insertionSortEquiv_order as ⟨i, Nat.succ_lt_succ_iff.mp hi⟩
      ⟨j, Nat.succ_lt_succ_iff.mp hj⟩ (byα:Typer:α → α → Propinst✝:DecidableRel ra:αas:List αi:ℕhi:i + 1 < (a :: as).lengthj:ℕhj:j + 1 < (a :: as).lengthhij:⟨i + 1, hi⟩ < ⟨j + 1, hj⟩hij':(orderedInsertEquiv r (List.insertionSort r as) a) ((insertionSortEquiv r as) ⟨j, ⋯⟩).succ <
  (orderedInsertEquiv r (List.insertionSort r as) a) ((insertionSortEquiv r as) ⟨i, ⋯⟩).succ⊢ ⟨i, ⋯⟩ < ⟨j, ⋯⟩ simpa using hijAll goals completed! 🐙)
      (orderedInsertEquiv_monotone_fin_succ _ _ _ _ _ hij')

Optional erase of an element in a list. For none returns the list, for some i returns the list with the i'th element erased.

@[`@[expose]` has no effect outside a `module` fileexpose] def optionErase {I : Type} (l : List I) (i : Option (Fin l.length)) : List I :=
  match i with
  | none => l
  | some i => List.eraseIdx l i

              lemma eraseIdx_length' {I : Type} (l : List I) (i : Fin l.length) :
    (List.eraseIdx l i).length = l.length - 1 := byI:Typel:List Ii:Fin l.length⊢ (l.eraseIdx ↑i).length = l.length - 1
  simp [List.length_eraseIdx]All goals completed! 🐙lemma eraseIdx_length {I : Type} (l : List I) (i : Fin l.length) :
    (List.eraseIdx l i).length + 1 = l.length :=
  List.length_eraseIdx_add_one i.isLtlemma eraseIdx_length_succ {I : Type} (l : List I) (i : Fin l.length) :
    (List.eraseIdx l i).length.succ = l.length :=
  List.length_eraseIdx_add_one i.isLtlemma eraseIdx_cons_length {I : Type} (a : I) (l : List I) (i : Fin (a :: l).length) :
    (List.eraseIdx (a :: l) i).length= l.length := byI:Typea:Il:List Ii:Fin (a :: l).length⊢ ((a :: l).eraseIdx ↑i).length = l.length
  simp [List.length_eraseIdx]All goals completed! 🐙

lemma eraseIdx_get {I : Type} (l : List I) (i : Fin l.length) :
    (List.eraseIdx l i).get = l.get ∘ (Fin.cast (eraseIdx_length l i)) ∘
    (Fin.cast (eraseIdx_length l i).symm i).succAbove := byI:Typel:List Ii:Fin l.length⊢ (l.eraseIdx ↑i).get = l.get ∘ Fin.cast ⋯ ∘ (Fin.cast ⋯ i).succAbove
  ext xI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).length⊢ (l.eraseIdx ↑i).get x = (l.get ∘ Fin.cast ⋯ ∘ (Fin.cast ⋯ i).succAbove) x
  simp only [Function.comp_apply, List.get_eq_getElem, List.getElem_eraseIdx]I:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).length⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑(Fin.cast ⋯ ((Fin.cast ⋯ i).succAbove x))]
  simp only [Fin.succAbove, Fin.val_cast]I:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).length⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑(if x.castSucc < Fin.cast ⋯ i then x.castSucc else x.succ)]
  by_cases hi: x.castSucc < Fin.cast (Eq.symm (eraseIdx_length l i)) iposI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi:x.castSucc < Fin.cast ⋯ i⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑(if x.castSucc < Fin.cast ⋯ i then x.castSucc else x.succ)]negI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi:¬x.castSucc < Fin.cast ⋯ i⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑(if x.castSucc < Fin.cast ⋯ i then x.castSucc else x.succ)]
  ·posI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi:x.castSucc < Fin.cast ⋯ i⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑(if x.castSucc < Fin.cast ⋯ i then x.castSucc else x.succ)] simp only [hi, ↓reduceIte, Fin.val_castSucc, dite_eq_left_iff, not_lt]posI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi:x.castSucc < Fin.cast ⋯ i⊢ ∀ (h : ↑i ≤ ↑x), l[↑x + 1] = l[↑x]
    intro hposI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi:x.castSucc < Fin.cast ⋯ ih:↑i ≤ ↑x⊢ l[↑x + 1] = l[↑x]
    rw [Fin.lt_defposI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi:↑x.castSucc < ↑(Fin.cast ⋯ i)h:↑i ≤ ↑x⊢ l[↑x + 1] = l[↑x]posI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi:↑x.castSucc < ↑(Fin.cast ⋯ i)h:↑i ≤ ↑x⊢ l[↑x + 1] = l[↑x]] at hiposI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi:↑x.castSucc < ↑(Fin.cast ⋯ i)h:↑i ≤ ↑x⊢ l[↑x + 1] = l[↑x]
    simp_all only [Fin.val_castSucc, Fin.val_cast]posI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthh:↑i ≤ ↑xhi:↑x < ↑i⊢ l[↑x + 1] = l[↑x]
    omegaAll goals completed! 🐙
  ·negI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi:¬x.castSucc < Fin.cast ⋯ i⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑(if x.castSucc < Fin.cast ⋯ i then x.castSucc else x.succ)] simp only [hi, ↓reduceIte, Fin.val_succ]negI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi:¬x.castSucc < Fin.cast ⋯ i⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑x + 1]
    rw [Fin.lt_defnegI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi✝:¬x.castSucc < Fin.cast ⋯ ihi:¬↑x.castSucc < ↑(Fin.cast ⋯ i)⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑x + 1]negI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi✝:¬x.castSucc < Fin.cast ⋯ ihi:¬↑x.castSucc < ↑(Fin.cast ⋯ i)⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑x + 1]] at hinegI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi✝:¬x.castSucc < Fin.cast ⋯ ihi:¬↑x.castSucc < ↑(Fin.cast ⋯ i)⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑x + 1]
    simp only [Fin.val_castSucc, Fin.val_cast, not_lt] at hinegI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi✝:¬x.castSucc < Fin.cast ⋯ ihi:↑i ≤ ↑x⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑x + 1]
    have hn : ¬ x.val < i.val := byI:Typel:List Ii:Fin l.length⊢ (l.eraseIdx ↑i).get = l.get ∘ Fin.cast ⋯ ∘ (Fin.cast ⋯ i).succAbovenegI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi✝:¬x.castSucc < Fin.cast ⋯ ihi:↑i ≤ ↑xhn:¬↑x < ↑i⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑x + 1] omeganegI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi✝:¬x.castSucc < Fin.cast ⋯ ihi:↑i ≤ ↑xhn:¬↑x < ↑i⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑x + 1]negI:Typel:List Ii:Fin l.lengthx:Fin (l.eraseIdx ↑i).lengthhi✝:¬x.castSucc < Fin.cast ⋯ ihi:↑i ≤ ↑xhn:¬↑x < ↑i⊢ (if h' : ↑x < ↑i then l[↑x] else l[↑x + 1]) = l[↑x + 1]
    simp [hn]All goals completed! 🐙

set_option backward.isDefEq.respectTransparency false in
lemma eraseIdx_insertionSort {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    [Std.Total le1] [IsTrans I le1] :
    (n : ℕ) → (r : List I) → (hn : n < r.length) →
    (List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, hn⟩)
    = List.insertionSort le1 (r.eraseIdx n)
  | 0, [], _ =>I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1x✝:0 < [].length⊢ (List.insertionSort le1 []).eraseIdx ↑((insertionSortEquiv le1 []) ⟨0, x✝⟩) = List.insertionSort le1 ([].eraseIdx 0) byI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1x✝:0 < [].length⊢ (List.insertionSort le1 []).eraseIdx ↑((insertionSortEquiv le1 []) ⟨0, x✝⟩) = List.insertionSort le1 ([].eraseIdx 0) rflAll goals completed! 🐙
  | 0, (r0 :: r), hn =>I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihn:0 < (r0 :: r).length⊢ (List.insertionSort le1 (r0 :: r)).eraseIdx ↑((insertionSortEquiv le1 (r0 :: r)) ⟨0, hn⟩) =
  List.insertionSort le1 ((r0 :: r).eraseIdx 0) byI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1r0:Ir:List Ihn:0 < (r0 :: r).length⊢ (List.insertionSort le1 (r0 :: r)).eraseIdx ↑((insertionSortEquiv le1 (r0 :: r)) ⟨0, hn⟩) =
  List.insertionSort le1 ((r0 :: r).eraseIdx 0)
    simp only [List.insertionSort, List.foldr_cons, List.length_cons, insertionSortEquiv,
      Nat.succ_eq_add_one, Fin.zero_eta, Equiv.trans_apply, equivCons_zero, orderedInsertEquiv_zero,
      orderedInsert_eraseIdx_orderedInsertPos, List.eraseIdx_zero, List.tail_cons]All goals completed! 🐙
  | Nat.succ n, [], hn =>I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕhn:n.succ < [].length⊢ (List.insertionSort le1 []).eraseIdx ↑((insertionSortEquiv le1 []) ⟨n.succ, hn⟩) =
  List.insertionSort le1 ([].eraseIdx n.succ) byI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕhn:n.succ < [].length⊢ (List.insertionSort le1 []).eraseIdx ↑((insertionSortEquiv le1 []) ⟨n.succ, hn⟩) =
  List.insertionSort le1 ([].eraseIdx n.succ) rflAll goals completed! 🐙
  | Nat.succ n, (r0 :: r), hn =>I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).length⊢ (List.insertionSort le1 (r0 :: r)).eraseIdx ↑((insertionSortEquiv le1 (r0 :: r)) ⟨n.succ, hn⟩) =
  List.insertionSort le1 ((r0 :: r).eraseIdx n.succ) byI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).length⊢ (List.insertionSort le1 (r0 :: r)).eraseIdx ↑((insertionSortEquiv le1 (r0 :: r)) ⟨n.succ, hn⟩) =
  List.insertionSort le1 ((r0 :: r).eraseIdx n.succ)
    simp only [List.insertionSort, List.length_cons, insertionSortEquiv, Nat.succ_eq_add_one,
      Equiv.trans_apply, equivCons_succ]I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).length⊢ (List.foldr (List.orderedInsert le1) [] (r0 :: r)).eraseIdx
    ↑((orderedInsertEquiv le1 (List.foldr (List.orderedInsert le1) [] r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
  List.foldr (List.orderedInsert le1) [] ((r0 :: r).eraseIdx (n + 1))
    have hOr := orderedInsert_eraseIdx_orderedInsertEquiv_fin_succ le1
      (List.insertionSort le1 r) r0 ((insertionSortEquiv le1 r) ⟨n, byI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).length⊢ n < r.lengthI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))⊢ (List.foldr (List.orderedInsert le1) [] (r0 :: r)).eraseIdx
    ↑((orderedInsertEquiv le1 (List.foldr (List.orderedInsert le1) [] r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
  List.foldr (List.orderedInsert le1) [] ((r0 :: r).eraseIdx (n + 1)) simpa using hnAll goals completed! 🐙I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))⊢ (List.foldr (List.orderedInsert le1) [] (r0 :: r)).eraseIdx
    ↑((orderedInsertEquiv le1 (List.foldr (List.orderedInsert le1) [] r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
  List.foldr (List.orderedInsert le1) [] ((r0 :: r).eraseIdx (n + 1))⟩)I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))⊢ (List.foldr (List.orderedInsert le1) [] (r0 :: r)).eraseIdx
    ↑((orderedInsertEquiv le1 (List.foldr (List.orderedInsert le1) [] r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
  List.foldr (List.orderedInsert le1) [] ((r0 :: r).eraseIdx (n + 1))
    erw [hOrI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))⊢ List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩)) =
  List.foldr (List.orderedInsert le1) [] ((r0 :: r).eraseIdx (n + 1))I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))⊢ ∀ (i j : Fin (List.insertionSort le1 r).length),
  i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)]I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))⊢ List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩)) =
  List.foldr (List.orderedInsert le1) [] ((r0 :: r).eraseIdx (n + 1))I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))⊢ ∀ (i j : Fin (List.insertionSort le1 r).length),
  i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)
    congre_aI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))⊢ (List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩) =
  List.foldr (List.orderedInsert le1) [] (r.eraseIdx n)I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))⊢ ∀ (i j : Fin (List.insertionSort le1 r).length),
  i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)
    refine eraseIdx_insertionSort le1 n r _I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))⊢ ∀ (i j : Fin (List.insertionSort le1 r).length),
  i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)
    intro i j hij hnI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn✝:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))i:Fin (List.insertionSort le1 r).lengthj:Fin (List.insertionSort le1 r).lengthhij:i < jhn:¬le1 r0 ((List.insertionSort le1 r).get j)⊢ ¬le1 r0 ((List.insertionSort le1 r).get i)
    have hx := List.Pairwise.rel_get_of_lt (R := le1) (l := (List.insertionSort le1 r))
      (List.pairwise_insertionSort le1 r) hijI:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn✝:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))i:Fin (List.insertionSort le1 r).lengthj:Fin (List.insertionSort le1 r).lengthhij:i < jhn:¬le1 r0 ((List.insertionSort le1 r).get j)hx:le1 ((List.insertionSort le1 r).get i) ((List.insertionSort le1 r).get j)⊢ ¬le1 r0 ((List.insertionSort le1 r).get i)
    have ht (i j k : I) (hij : le1 i j) (hjk : ¬ le1 k j) : ¬ le1 k i :=
      fun hik => hjk (IsTrans.trans (r := le1) k i j hik hij)I:Typele1:I → I → Propinst✝²:DecidableRel le1inst✝¹:Std.Total le1inst✝:IsTrans I le1n:ℕr0:Ir:List Ihn✝:n.succ < (r0 :: r).lengthhOr:(∀ (i j : Fin (List.insertionSort le1 r).length),
    i < j → ¬le1 r0 ((List.insertionSort le1 r).get j) → ¬le1 r0 ((List.insertionSort le1 r).get i)) →
  (List.orderedInsert le1 r0 (List.insertionSort le1 r)).eraseIdx
      ↑((orderedInsertEquiv le1 (List.insertionSort le1 r) r0) ((insertionSortEquiv le1 r) ⟨n, ⋯⟩).succ) =
    List.orderedInsert le1 r0 ((List.insertionSort le1 r).eraseIdx ↑((insertionSortEquiv le1 r) ⟨n, ⋯⟩))i:Fin (List.insertionSort le1 r).lengthj:Fin (List.insertionSort le1 r).lengthhij:i < jhn:¬le1 r0 ((List.insertionSort le1 r).get j)hx:le1 ((List.insertionSort le1 r).get i) ((List.insertionSort le1 r).get j)ht:∀ (i j k : I), le1 i j → ¬le1 k j → ¬le1 k i⊢ ¬le1 r0 ((List.insertionSort le1 r).get i)
    exact ht ((List.insertionSort le1 r).get i) ((List.insertionSort le1 r).get j) r0 hx hnAll goals completed! 🐙lemma eraseIdx_insertionSort_fin {I : Type} (le1 : I → I → Prop) [DecidableRel le1]
    [Std.Total le1] [IsTrans I le1] (r : List I) (n : Fin r.length) :
    (List.insertionSort le1 r).eraseIdx ↑((Physlib.List.insertionSortEquiv le1 r) n)
    = List.insertionSort le1 (r.eraseIdx n) :=
  eraseIdx_insertionSort le1 n.val r (Fin.prop n)

Given a list i :: l the left-most minimal position a of i :: l wrt r. That is the first position of l such that for every element (i :: l)[b] before that position r ((i :: l)[b]) ((i :: l)[a]) is not true. The use of i :: l here rather then just l is to ensure that such a position exists. .


@[`@[expose]` has no effect outside a `module` fileexpose]
def insertionSortMinPos {α : Type} (r : α → α → Prop) [DecidableRel r] (i : α) (l : List α) :
    Fin (i :: l).length := (insertionSortEquiv r (i :: l)).symm ⟨0, byn:ℕα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (List.insertionSort r (i :: l)).length
    rw [insertionSort_lengthn:ℕα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (i :: l).lengthn:ℕα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (i :: l).length]n:ℕα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (i :: l).length
    exact Nat.zero_lt_succ l.lengthAll goals completed! 🐙⟩

The element of i :: l at insertionSortMinPos.

@[`@[expose]` has no effect outside a `module` fileexpose] def insertionSortMin {α : Type} (r : α → α → Prop) [DecidableRel r] (i : α) (l : List α) :
    α := (i :: l).get (insertionSortMinPos r i l)



lemma insertionSortMin_eq_insertionSort_head {α : Type} (r : α → α → Prop) [DecidableRel r]
    (i : α) (l : List α) :
    insertionSortMin r i l = (List.insertionSort r (i :: l)).head (byn:ℕα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ List.insertionSort r (i :: l) ≠ []
    refine List.ne_nil_of_length_pos ?_n:ℕα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (List.insertionSort r (i :: l)).length
    rw [insertionSort_lengthn:ℕα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (i :: l).lengthn:ℕα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (i :: l).length]n:ℕα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (i :: l).length
    exact Nat.zero_lt_succ l.lengthAll goals completed! 🐙) := byα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ insertionSortMin r i l = (List.insertionSort r (i :: l)).head ⋯
  trans (List.insertionSort r (i :: l)).get (⟨0, byα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (List.insertionSort r (i :: l)).length
    rw [insertionSort_lengthα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (i :: l).lengthα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (i :: l).length]α:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ 0 < (i :: l).length; exact Nat.zero_lt_succ l.lengthAll goals completed! 🐙⟩)
  ·α:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ insertionSortMin r i l = (List.insertionSort r (i :: l)).get ⟨0, ⋯⟩ rw [← insertionSortEquiv_getα:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ insertionSortMin r i l = ((i :: l).get ∘ ⇑(insertionSortEquiv r (i :: l)).symm) ⟨0, ⋯⟩α:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ insertionSortMin r i l = ((i :: l).get ∘ ⇑(insertionSortEquiv r (i :: l)).symm) ⟨0, ⋯⟩]α:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ insertionSortMin r i l = ((i :: l).get ∘ ⇑(insertionSortEquiv r (i :: l)).symm) ⟨0, ⋯⟩
    rflAll goals completed! 🐙
  ·α:Typer:α → α → Propinst✝:DecidableRel ri:αl:List α⊢ (List.insertionSort r (i :: l)).get ⟨0, ⋯⟩ = (List.insertionSort r (i :: l)).head ⋯ exact List.get_mk_zero _All goals completed! 🐙

The list remaining after dropping the element at the position determined by insertionSortMinPos.

@[`@[expose]` has no effect outside a `module` fileexpose]
def insertionSortDropMinPos {α : Type} (r : α → α → Prop) [DecidableRel r] (i : α) (l : List α) :
    List α := (i :: l).eraseIdx (insertionSortMinPos r i l)



lemma insertionSort_eq_insertionSortMin_cons {α : Type} (r : α → α → Prop) [DecidableRel r]
    [Std.Total r] [IsTrans α r] (i : α) (l : List α) :
    List.insertionSort r (i :: l) =
    (insertionSortMin r i l) :: List.insertionSort r (insertionSortDropMinPos r i l) := byα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α⊢ List.insertionSort r (i :: l) = insertionSortMin r i l :: List.insertionSort r (insertionSortDropMinPos r i l)
  rw [insertionSortDropMinPos,α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α⊢ List.insertionSort r (i :: l) =
  insertionSortMin r i l :: List.insertionSort r ((i :: l).eraseIdx ↑(insertionSortMinPos r i l))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α⊢ List.insertionSort r (i :: l) =
  insertionSortMin r i l ::
    (List.insertionSort r (i :: l)).eraseIdx ↑((insertionSortEquiv r (i :: l)) (insertionSortMinPos r i l)) ← eraseIdx_insertionSort_finα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α⊢ List.insertionSort r (i :: l) =
  insertionSortMin r i l ::
    (List.insertionSort r (i :: l)).eraseIdx ↑((insertionSortEquiv r (i :: l)) (insertionSortMinPos r i l))α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α⊢ List.insertionSort r (i :: l) =
  insertionSortMin r i l ::
    (List.insertionSort r (i :: l)).eraseIdx ↑((insertionSortEquiv r (i :: l)) (insertionSortMinPos r i l))]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α⊢ List.insertionSort r (i :: l) =
  insertionSortMin r i l ::
    (List.insertionSort r (i :: l)).eraseIdx ↑((insertionSortEquiv r (i :: l)) (insertionSortMinPos r i l))
  conv_rhs =>
    rhsα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α| (List.insertionSort r (i :: l)).eraseIdx ↑((insertionSortEquiv r (i :: l)) (insertionSortMinPos r i l))
    rhsα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α| ↑((insertionSortEquiv r (i :: l)) (insertionSortMinPos r i l))
    rw [insertionSortMinPos, Equiv.apply_symm_apply]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α| ↑⟨0, ⋯⟩
  simp only [List.insertionSort, List.eraseIdx_zero]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α⊢ List.foldr (List.orderedInsert r) [] (i :: l) =
  insertionSortMin r i l :: (List.foldr (List.orderedInsert r) [] (i :: l)).tail
  rw [insertionSortMin_eq_insertionSort_headα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α⊢ List.foldr (List.orderedInsert r) [] (i :: l) =
  (List.insertionSort r (i :: l)).head ⋯ :: (List.foldr (List.orderedInsert r) [] (i :: l)).tailα:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α⊢ List.foldr (List.orderedInsert r) [] (i :: l) =
  (List.insertionSort r (i :: l)).head ⋯ :: (List.foldr (List.orderedInsert r) [] (i :: l)).tail]α:Typer:α → α → Propinst✝²:DecidableRel rinst✝¹:Std.Total rinst✝:IsTrans α ri:αl:List α⊢ List.foldr (List.orderedInsert r) [] (i :: l) =
  (List.insertionSort r (i :: l)).head ⋯ :: (List.foldr (List.orderedInsert r) [] (i :: l)).tail
  exact (List.cons_head_tail _).symmAll goals completed! 🐙

Optional erase of an element in a list, with addition for none. For none adds a to the front of the list, for some i removes the ith element of the list (does not add a). E.g. optionEraseZ [0, 1, 2] 4 none = [4, 0, 1, 2] and optionEraseZ [0, 1, 2] 4 (some 1) = [0, 2].

@[`@[expose]` has no effect outside a `module` fileexpose] def optionEraseZ {I : Type} (l : List I) (a : I) (i : Option (Fin l.length)) : List I :=
  match i with
  | none => a :: l
  | some i => List.eraseIdx l i

              @[simp]
lemma optionEraseZ_some_length {I : Type} (l : List I) (a : I) (i : (Fin l.length)) :
    (optionEraseZ l a (some i)).length = l.length - 1 := byI:Typel:List Ia:Ii:Fin l.length⊢ (optionEraseZ l a (some i)).length = l.length - 1
  simp [optionEraseZ, List.length_eraseIdx]All goals completed! 🐙

lemma optionEraseZ_ext {I : Type} {l l' : List I} {a a' : I} {i : Option (Fin l.length)}
    {i' : Option (Fin l'.length)} (hl : l = l') (ha : a = a')
    (hi : Option.map (Fin.cast (byn:ℕI:Typel:List Il':List Ia:Ia':Ii:Option (Fin l.length)i':Option (Fin l'.length)hl:l = l'ha:a = a'⊢ l.length = l'.length rw [hln:ℕI:Typel:List Il':List Ia:Ia':Ii:Option (Fin l.length)i':Option (Fin l'.length)hl:l = l'ha:a = a'⊢ l'.length = l'.lengthAll goals completed! 🐙]All goals completed! 🐙)) i = i') :
    optionEraseZ l a i = optionEraseZ l' a' i' := byI:Typel:List Il':List Ia:Ia':Ii:Option (Fin l.length)i':Option (Fin l'.length)hl:l = l'ha:a = a'hi:Option.map (Fin.cast ⋯) i = i'⊢ optionEraseZ l a i = optionEraseZ l' a' i'
  subst hlI:Typel:List Ia:Ia':Ii:Option (Fin l.length)ha:a = a'i':Option (Fin l.length)hi:Option.map (Fin.cast ⋯) i = i'⊢ optionEraseZ l a i = optionEraseZ l a' i'
  subst haI:Typel:List Ia:Ii:Option (Fin l.length)i':Option (Fin l.length)hi:Option.map (Fin.cast ⋯) i = i'⊢ optionEraseZ l a i = optionEraseZ l a i'
  cases hireflI:Typel:List Ia:Ii:Option (Fin l.length)⊢ optionEraseZ l a i = optionEraseZ l a (Option.map (Fin.cast ⋯) i)
  congrrefl.e_iI:Typel:List Ia:Ii:Option (Fin l.length)⊢ i = Option.map (Fin.cast ⋯) i
  simpAll goals completed! 🐙

lemma mem_take_finrange : (n m : ℕ) → (a : Fin n) → a ∈ List.take m (List.finRange n) ↔ a.val < m
  | 0, m, a => Fin.elim0 a
  | n+1, 0, a =>n:ℕa:Fin (n + 1)⊢ a ∈ List.take 0 (List.finRange (n + 1)) ↔ ↑a < 0 byn:ℕa:Fin (n + 1)⊢ a ∈ List.take 0 (List.finRange (n + 1)) ↔ ↑a < 0
    simpAll goals completed! 🐙
  | n +1, m + 1, ⟨0, h⟩ =>n:ℕm:ℕh:0 < n + 1⊢ ⟨0, h⟩ ∈ List.take (m + 1) (List.finRange (n + 1)) ↔ ↑⟨0, h⟩ < m + 1 byn:ℕm:ℕh:0 < n + 1⊢ ⟨0, h⟩ ∈ List.take (m + 1) (List.finRange (n + 1)) ↔ ↑⟨0, h⟩ < m + 1
    simp [List.finRange_succ]All goals completed! 🐙
  | n +1, m + 1, ⟨i + 1, h⟩ =>n:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ ⟨i + 1, h⟩ ∈ List.take (m + 1) (List.finRange (n + 1)) ↔ ↑⟨i + 1, h⟩ < m + 1 byn:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ ⟨i + 1, h⟩ ∈ List.take (m + 1) (List.finRange (n + 1)) ↔ ↑⟨i + 1, h⟩ < m + 1
    simp only [List.finRange_succ, List.take_succ_cons, List.mem_cons, Fin.ext_iff, Fin.val_zero,
      AddLeftCancelMonoid.add_eq_zero, one_ne_zero, and_false, false_or, add_lt_add_iff_right]n:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ ⟨i + 1, h⟩ ∈ List.take m (List.map Fin.succ (List.finRange n)) ↔ i < m
    rw [← List.map_take,n:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ ⟨i + 1, h⟩ ∈ List.map Fin.succ (List.take m (List.finRange n)) ↔ i < mn:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ (∃ a ∈ List.take m (List.finRange n), a.succ = ⟨i + 1, h⟩) ↔ i < m @List.mem_mapn:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ (∃ a ∈ List.take m (List.finRange n), a.succ = ⟨i + 1, h⟩) ↔ i < mn:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ (∃ a ∈ List.take m (List.finRange n), a.succ = ⟨i + 1, h⟩) ↔ i < m]n:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ (∃ a ∈ List.take m (List.finRange n), a.succ = ⟨i + 1, h⟩) ↔ i < m
    apply Iff.intrompn:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ (∃ a ∈ List.take m (List.finRange n), a.succ = ⟨i + 1, h⟩) → i < mmprn:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ i < m → ∃ a ∈ List.take m (List.finRange n), a.succ = ⟨i + 1, h⟩
    ·mpn:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ (∃ a ∈ List.take m (List.finRange n), a.succ = ⟨i + 1, h⟩) → i < m intro hmpn:ℕm:ℕi:ℕh✝:i + 1 < n + 1h:∃ a ∈ List.take m (List.finRange n), a.succ = ⟨i + 1, h✝⟩⊢ i < m
      obtain ⟨a, ha⟩ := hmpn:ℕm:ℕi:ℕh:i + 1 < n + 1a:Fin nha:a ∈ List.take m (List.finRange n) ∧ a.succ = ⟨i + 1, h⟩⊢ i < m
      rw [mem_take_finrange n m a,mpn:ℕm:ℕi:ℕh:i + 1 < n + 1a:Fin nha:↑a < m ∧ a.succ = ⟨i + 1, h⟩⊢ i < mmpn:ℕm:ℕi:ℕh:i + 1 < n + 1a:Fin nha:↑a < m ∧ ↑a.succ = ↑⟨i + 1, h⟩⊢ i < m Fin.ext_iffmpn:ℕm:ℕi:ℕh:i + 1 < n + 1a:Fin nha:↑a < m ∧ ↑a.succ = ↑⟨i + 1, h⟩⊢ i < mmpn:ℕm:ℕi:ℕh:i + 1 < n + 1a:Fin nha:↑a < m ∧ ↑a.succ = ↑⟨i + 1, h⟩⊢ i < m] at hampn:ℕm:ℕi:ℕh:i + 1 < n + 1a:Fin nha:↑a < m ∧ ↑a.succ = ↑⟨i + 1, h⟩⊢ i < m
      simp_all only [Fin.val_succ, add_left_inj]mpn:ℕm:ℕi:ℕh:i + 1 < n + 1a:Fin nha:↑a < m ∧ ↑a = i⊢ i < m
      omegaAll goals completed! 🐙
    ·mprn:ℕm:ℕi:ℕh:i + 1 < n + 1⊢ i < m → ∃ a ∈ List.take m (List.finRange n), a.succ = ⟨i + 1, h⟩ intro h1mprn:ℕm:ℕi:ℕh:i + 1 < n + 1h1:i < m⊢ ∃ a ∈ List.take m (List.finRange n), a.succ = ⟨i + 1, h✝⟩
      use ⟨i, Nat.succ_lt_succ_iff.mp h⟩hn:ℕm:ℕi:ℕh:i + 1 < n + 1h1:i < m⊢ ⟨i, ⋯⟩ ∈ List.take m (List.finRange n) ∧ ⟨i, ⋯⟩.succ = ⟨i + 1, h⟩
      simp only [Fin.succ_mk, and_true]hn:ℕm:ℕi:ℕh:i + 1 < n + 1h1:i < m⊢ ⟨i, ⋯⟩ ∈ List.take m (List.finRange n)
      rwa [mem_take_finrange n m ⟨i, Nat.succ_lt_succ_iff.mp h⟩hn:ℕm:ℕi:ℕh:i + 1 < n + 1h1:i < m⊢ ↑⟨i, ⋯⟩ < m]hn:ℕm:ℕi:ℕh:i + 1 < n + 1h1:i < m⊢ ↑⟨i, ⋯⟩ < m