Imports
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 takeWile_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 : Type P : I → Prop inst✝ : DecidablePred P x✝ : ℕ 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✝ by I : Type P : I → Prop inst✝ : DecidablePred P x✝ : ℕ 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✝
rfl All goals completed! 🐙
| a :: [ ] , 0 , h => I : Type P : I → Prop inst✝ : DecidablePred P a : I 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 0 ) = ( List.takeWhile (fun b => decide ( P b ) ) [ a ] ) . eraseIdx 0 by I : Type P : I → Prop inst✝ : DecidablePred P a : I 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 0 ) = ( List.takeWhile (fun b => decide ( P b ) ) [ a ] ) . eraseIdx 0
simp only [ List.takeWhile , List.eraseIdx_zero ] I : Type P : I → Prop inst✝ : DecidablePred P a : I h : ∀ ( 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
split h_1 I : Type P : I → Prop inst✝ : DecidablePred P a : I h : ∀ ( i j : Fin [ a ] . length ), i < j → P ( [ a ] . get j ) → P ( [ a ] . get i ) x✝ : Bool heq✝ : decide ( P a ) = true ⊢ List.takeWhile (fun b => decide ( P b ) ) [ a ] . tail = [ a ] . tail h_2 I : Type P : I → Prop inst✝ : DecidablePred P a : I h : ∀ ( i j : Fin [ a ] . length ), i < j → P ( [ a ] . get j ) → P ( [ a ] . get i ) x✝ : Bool heq✝ : decide ( P a ) = false ⊢ List.takeWhile (fun b => decide ( P b ) ) [ a ] . tail = [ ] . tail <;> h_1 I : Type P : I → Prop inst✝ : DecidablePred P a : I h : ∀ ( i j : Fin [ a ] . length ), i < j → P ( [ a ] . get j ) → P ( [ a ] . get i ) x✝ : Bool heq✝ : decide ( P a ) = true ⊢ List.takeWhile (fun b => decide ( P b ) ) [ a ] . tail = [ a ] . tail h_2 I : Type P : I → Prop inst✝ : DecidablePred P a : I h : ∀ ( i j : Fin [ a ] . length ), i < j → P ( [ a ] . get j ) → P ( [ a ] . get i ) x✝ : Bool heq✝ : decide ( P a ) = false ⊢ List.takeWhile (fun b => decide ( P b ) ) [ a ] . tail = [ ] . tail rfl All goals completed! 🐙
| a :: [ ] , Nat.succ n , h => I : Type P : I → Prop inst✝ : DecidablePred P a : I n : ℕ 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 by I : Type P : I → Prop inst✝ : DecidablePred P a : I n : ℕ 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 : Type P : I → Prop inst✝ : DecidablePred P a : I n : ℕ 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 ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I n : ℕ h : ∀ ( i j : Fin [ a ] . length ), i < j → P ( [ a ] . get j ) → P ( [ a ] . get i ) ⊢ [ a ] . length ≤ n + 1 All goals completed! 🐙 simp All goals completed! 🐙 All goals completed! 🐙 ) ) ] All goals completed! 🐙
| a :: b :: l , 0 , h => I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 0 ) =
( List.takeWhile (fun b => decide ( P b ) ) ( a :: b :: l ) ) . eraseIdx 0 by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 0 ) =
( List.takeWhile (fun b => decide ( P b ) ) ( a :: b :: l ) ) . eraseIdx 0
simp only [ List.takeWhile , List.eraseIdx_zero ] I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 ) . 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 b pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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.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 neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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.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
· pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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.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 := by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 0 ) =
( List.takeWhile (fun b => decide ( P b ) ) ( a :: b :: l ) ) . eraseIdx 0 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 , by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 ) . length pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 , by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 ) . length pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 ⟩ ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 , ⋯ ⟩ pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 ) ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 , ⋯ ⟩ ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 hPb All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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! 🐙
· neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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.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 ] neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 => [ a ]
| false => [ ] ) . tail =
[ ]
split h_1 I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 x✝ : Bool heq✝ : decide ( P a ) = true ⊢ [ a ] . tail = [ ] h_2 I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 x✝ : Bool heq✝ : decide ( P a ) = false ⊢ [ ] . tail = [ ] <;> h_1 I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 x✝ : Bool heq✝ : decide ( P a ) = true ⊢ [ a ] . tail = [ ] h_2 I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 x✝ : Bool heq✝ : decide ( P a ) = false ⊢ [ ] . tail = [ ] rfl All goals completed! 🐙
| a :: b :: l , Nat.succ n , h => I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 a pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 ) neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 )
· pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 ] pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 ] pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 takeWile_eraseIdx P ( b :: l ) n fun i j hij hP => by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 i : Fin ( b :: l ) . length j : Fin ( b :: l ) . length hij : i < j hP : P ( ( b :: l ) . get j ) ⊢ P ( ( b :: l ) . get i )
simpa using h i . succ j . succ ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 i : Fin ( b :: l ) . length j : Fin ( b :: l ) . length hij : i < j hP : P ( ( b :: l ) . get j ) ⊢ i . succ < j . succ simpa using hij All goals completed! 🐙 ) ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 i : Fin ( b :: l ) . length j : Fin ( b :: l ) . length hij : i < j hP : P ( ( b :: l ) . get j ) ⊢ P ( ( a :: b :: l ) . get j . succ ) simpa using hP All goals completed! 🐙 )
· neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 : Type P : I → Prop inst✝ : DecidablePred P x✝ : ℕ 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 ) ) [ ] by I : Type P : I → Prop inst✝ : DecidablePred P x✝ : ℕ 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 ) ) [ ]
simp All goals completed! 🐙
| a :: [ ] , 0 , h => I : Type P : I → Prop inst✝ : DecidablePred P a : I 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 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 I : Type P : I → Prop inst✝ : DecidablePred P a : I 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 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 a pos I : Type P : I → Prop inst✝ : DecidablePred P a : I 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 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 ] neg I : Type P : I → Prop inst✝ : DecidablePred P a : I 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 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 ] <;> pos I : Type P : I → Prop inst✝ : DecidablePred P a : I 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 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 ] neg I : Type P : I → Prop inst✝ : DecidablePred P a : I 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 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 : Type P : I → Prop inst✝ : DecidablePred P a : I n : ℕ 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 I : Type P : I → Prop inst✝ : DecidablePred P a : I n : ℕ 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 a pos I : Type P : I → Prop inst✝ : DecidablePred P a : I n : ℕ 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 ] neg I : Type P : I → Prop inst✝ : DecidablePred P a : I n : ℕ 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 ] <;> pos I : Type P : I → Prop inst✝ : DecidablePred P a : I n : ℕ 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 ] neg I : Type P : I → Prop inst✝ : DecidablePred P a : I n : ℕ 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 : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 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 I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 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 b pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 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 ) neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 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 )
· pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 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 , by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 ) . length pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 , by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 ) . length pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 ) ⟩ ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 , ⋯ ⟩ pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 ) ) ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 , ⋯ ⟩ ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 hPb All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 ) ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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! 🐙
· neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 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 a pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 ) neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : ¬ 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 ) <;> pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : 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 ) neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I 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 hPa : ¬ 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 : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 ) by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 b pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 ) neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 )
· pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 := by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 , by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 ) . length pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 , by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 ) . length pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 ) ⟩ ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 , ⋯ ⟩ pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 ) ) ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 , ⋯ ⟩ ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 hPb All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 ) ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 ] pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 => by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : P a i : Fin ( b :: l ) . length j : Fin ( b :: l ) . length hij : i < j hP : P ( ( b :: l ) . get j ) ⊢ P ( ( b :: l ) . get i ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : P a i : Fin ( b :: l ) . length j : Fin ( b :: l ) . length hij : i < j hP : P ( ( b :: l ) . get j ) ⊢ i . succ < j . succ pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 hij All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 ) ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : P a i : Fin ( b :: l ) . length j : Fin ( b :: l ) . length hij : i < j hP : P ( ( b :: l ) . get j ) ⊢ P ( ( a :: b :: l ) . get j . succ ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 hP All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 ) ) ] pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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! 🐙
· neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 ] neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 a pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : ¬ 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
· pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 => by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : P a i : Fin ( b :: l ) . length j : Fin ( b :: l ) . length hij : i < j hP : P ( ( b :: l ) . get j ) ⊢ P ( ( b :: l ) . get i ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : P a i : Fin ( b :: l ) . length j : Fin ( b :: l ) . length hij : i < j hP : P ( ( b :: l ) . get j ) ⊢ i . succ < j . succ pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 hij All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 ) ( by I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : P a i : Fin ( b :: l ) . length j : Fin ( b :: l ) . length hij : i < j hP : P ( ( b :: l ) . get j ) ⊢ P ( ( a :: b :: l ) . get j . succ ) pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 hP All goals completed! 🐙 pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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 ) ) ] pos I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : 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! 🐙
· neg I : Type P : I → Prop inst✝ : DecidablePred P a : I b : I l : List I n : ℕ 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 hPa : ¬ 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` file expose ]
def orderedInsertPos { I : Type } ( le1 : I → I → Prop ) [ DecidableRel le1 ] ( r : List I ) ( r0 : I ) :
Fin ( List.orderedInsert le1 r0 r ) . length :=
⟨ ( List.takeWhile ( fun b => decide ¬ le1 r0 b ) r ) . length , by n : ℕ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length < ( List.orderedInsert le1 r0 r ) . length
rw [ List.orderedInsert_length n : ℕ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length < r . length + 1 n : ℕ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length < r . length + 1 ] n : ℕ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I h1 : ( 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
omega All 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ↑ ( orderedInsertPos le1 r r0 ) < ( r0 :: r ) . length
simp only [ orderedInsertPos , List.length_cons ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length < r . length + 1
exact Nat.lt_succ_of_le ( List.takeWhile_sublist _ ) . length_le All 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.orderedInsert le1 r0 r ) . eraseIdx ↑ ( orderedInsertPos le1 r r0 ) = r
simp only [ List.orderedInsert_eq_take_drop ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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_le I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 hk I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ ↑ ( orderedInsertPos le1 r r0 ) I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 hk I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ ↑ ( orderedInsertPos le1 r r0 ) ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 hk I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ ↑ ( orderedInsertPos le1 r r0 )
· I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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! 🐙
· hk I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ ↑ ( orderedInsertPos le1 r r0 ) rfl All 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 , by n : ℕ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I r1 : I ⊢ 0 < ( List.orderedInsert le1 r0 r ) . length + 1 simp All goals completed! 🐙 ⟩ else ( Fin.succ ( orderedInsertPos le1 r r0 ) ) := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I r1 : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I r1 : 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 r1 pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I r1 : I h : 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 , ⋯ ⟩ ) neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I r1 : I h : ¬ 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 , ⋯ ⟩ ) <;> pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I r1 : I h : 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 , ⋯ ⟩ ) neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I r1 : I h : ¬ 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 := by I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) k : I a : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) k : I a : 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 => nil I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 k : I a : 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
simp All goals completed! 🐙
| cons a l ih => cons I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 k : I a✝ : f k a : ( i : I ) × f i l : 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 ] cons I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 k : I a✝ : f k a : ( i : I ) × f i l : 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 ⟩ := a cons I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 k : I a : f k l : 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 fst : I snd : 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 only cons I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 k : I a : f k l : 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 fst : I snd : 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
split h_1 I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 k : I a : f k l : 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 fst : I snd : f fst x✝ : Bool heq✝ : ( ! 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 ) ) ) . length h_2 I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 k : I a : f k l : 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 fst : I snd : f fst x✝ : Bool heq✝ : ( ! 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_1 I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 k : I a : f k l : 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 fst : I snd : f fst x✝ : Bool heq✝ : ( ! 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 ) ) ) . length h_2 I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 k : I a : f k l : 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 fst : I snd : f fst x✝ : Bool heq✝ : ( ! 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_all All 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 , by n : ℕ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ hi : i < ↑ ( orderedInsertPos le1 r r0 ) ⊢ i < r . length
simp only [ orderedInsertPos ] at hi n : ℕ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ hi : i < ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length h1 : ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ r . length ⊢ i < r . length
omega All goals completed! 🐙 ⟩ := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ hi : i < ↑ ( orderedInsertPos le1 r r0 ) ⊢ ( List.orderedInsert le1 r0 r ) [ i ] = r . get ⟨ i , ⋯ ⟩
simp only [ orderedInsertPos , decide_not ] at hi I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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_append I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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.getElem I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ hi✝ : i < ↑ ( orderedInsertPos le1 r r0 ) hi : i < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length ⊢ ?m.64 [ i ] = r [ i ] h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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.64 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ hi✝ : i < ↑ ( orderedInsertPos le1 r r0 ) hi : i < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length ⊢ List I h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 ] h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 := by I : Type le1 : I → I → Prop inst✝ : 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
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 ) := by I : Type le1 : I → I → Prop inst✝ : 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 )
refine List.ext_get ? _ ? _ refine_1 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ) . length =
( List.take (↑ ( orderedInsertPos le1 r r0 ) ) ( List.orderedInsert le1 r0 r ) ) . length refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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_1 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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_1 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ↑ ( orderedInsertPos le1 r r0 ) ≤ r . length
exact Nat.le_of_lt_succ ( orderedInsertPos_lt_length le1 r r0 ) All goals completed! 🐙
· refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 h2 refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ) . length h2 : 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_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ) . length h2 : 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 n refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ) . length h2 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) ( List.orderedInsert le1 r0 r ) ) . length ⊢ r [ n ] = r . get ⟨ n , ⋯ ⟩ refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ) . length h2 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) ( List.orderedInsert le1 r0 r ) ) . length ⊢ n < ↑ ( orderedInsertPos le1 r r0 ) refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ) . length h2 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) ( List.orderedInsert le1 r0 r ) ) . length ⊢ r [ n ] = r . get ⟨ n , ⋯ ⟩ refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ) . length h2 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) ( List.orderedInsert le1 r0 r ) ) . length ⊢ n < ↑ ( orderedInsertPos le1 r r0 ) ] refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ) . length h2 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) ( List.orderedInsert le1 r0 r ) ) . length ⊢ r [ n ] = r . get ⟨ n , ⋯ ⟩ refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ) . length h2 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) ( List.orderedInsert le1 r0 r ) ) . length ⊢ n < ↑ ( orderedInsertPos le1 r r0 )
rfl refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ) . length h2 : 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 h1 refine_2 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h2 : n < ( List.take (↑ ( orderedInsertPos le1 r r0 ) ) ( List.orderedInsert le1 r0 r ) ) . length h1 : n < ↑ ( orderedInsertPos le1 r r0 ) ∧ n < r . length ⊢ n < ↑ ( orderedInsertPos le1 r r0 )
exact h1 . 1 All 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 ) := by I : Type le1 : I → I → Prop inst✝ : 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 )
conv_rhs => simp [ orderedInsertPos , List.orderedInsert_eq_take_drop ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 := by I : Type le1 : I → I → Prop inst✝ : 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 ) I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I hr : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I hr : 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 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I hr : 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 =>
rhs I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I hr : r = List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ++ List.dropWhile (fun b => ! decide ( le1 r0 b ) ) r | r
rw [ hr ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I hr : 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_append I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I hr : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I hr : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I hr : 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ List.take (↑ ( orderedInsertPos le1 r r0 ) ) r = List.takeWhile (fun b => decide ¬ le1 r0 b ) r
rw [ orderedInsertPos_take_eq_orderedInsert , I : Type le1 : I → I → Prop inst✝ : 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 All goals completed! 🐙 orderedInsertPos_take_orderedInsert I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ List.takeWhile (fun b => decide ¬ le1 r0 b ) r = List.takeWhile (fun b => decide ¬ le1 r0 b ) r All 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ List.drop (↑ ( orderedInsertPos le1 r r0 ) ) r = List.dropWhile (fun b => decide ¬ le1 r0 b ) r
rw [ orderedInsertPos_drop_eq_orderedInsert I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ List.drop (↑ ( orderedInsertPos le1 r r0 ) . succ ) ( List.orderedInsert le1 r0 r ) =
List.dropWhile (fun b => decide ¬ le1 r0 b ) r I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ List.drop (↑ ( orderedInsertPos le1 r r0 ) . succ ) ( List.orderedInsert le1 r0 r ) =
List.dropWhile (fun b => decide ¬ le1 r0 b ) r ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 ] := by I : Type le1 : I → I → Prop inst✝ : 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 ]
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 ) := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ 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_getElem I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ ∃ j , ∃ ( hm : j < min (↑ ( orderedInsertPos le1 r r0 ) ) r . length ), r [ j ] = r . get n I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ ∃ j , ∃ ( hm : j < min (↑ ( orderedInsertPos le1 r r0 ) ) r . length ), r [ j ] = r . get n I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ n < ↑ ( orderedInsertPos le1 r r0 ) htake : r . get n ∈ List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ⊢ ¬ le1 r0 ( r . get n ) ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ ∃ j , ∃ ( hm : j < min (↑ ( orderedInsertPos le1 r r0 ) ) r . length ), r [ j ] = r . get n I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ n < ↑ ( orderedInsertPos le1 r r0 ) htake : r . get n ∈ List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ⊢ ¬ le1 r0 ( r . get n )
use n h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ ∃ ( hm : ↑ n < min (↑ ( orderedInsertPos le1 r r0 ) ) r . length ), r [ ↑ n ] = r . get n I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ 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 hn I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ n < ↑ ( orderedInsertPos le1 r r0 ) htake : r . get n ∈ List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ⊢ ¬ le1 r0 ( r . get n ) I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ n < ↑ ( orderedInsertPos le1 r r0 ) htake : r . get n ∈ List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ⊢ ¬ le1 r0 ( r . get n )
rw [ orderedInsertPos_take I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ n < ↑ ( orderedInsertPos le1 r r0 ) htake : r . get n ∈ List.takeWhile (fun b => decide ¬ le1 r0 b ) r ⊢ ¬ le1 r0 ( r . get n ) I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ n < ↑ ( orderedInsertPos le1 r r0 ) htake : r . get n ∈ List.takeWhile (fun b => decide ¬ le1 r0 b ) r ⊢ ¬ le1 r0 ( r . get n ) ] at htake I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin r . length hn : ↑ 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 htake All 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 ) := by I : Type le1 : I → I → Prop inst✝ : 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 )
have htake : ( List.orderedInsert le1 r0 r ) . get n ∈ List.take ( orderedInsertPos le1 r r0 ) r := by
rw [ orderedInsertPos_take_eq_orderedInsert , I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : n < orderedInsertPos le1 r r0 ⊢ ( List.orderedInsert le1 r0 r ) . get n ∈ List.take (↑ ( orderedInsertPos le1 r r0 ) ) ( List.orderedInsert le1 r0 r ) I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : 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 n I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : n < orderedInsertPos le1 r r0 htake : ( 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_getElem I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : 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 n I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : 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 n I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : n < orderedInsertPos le1 r r0 htake : ( List.orderedInsert le1 r0 r ) . get n ∈ List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ⊢ ¬ le1 r0 ( ( List.orderedInsert le1 r0 r ) . get n ) ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : 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 n I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : n < orderedInsertPos le1 r r0 htake : ( List.orderedInsert le1 r0 r ) . get n ∈ List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ⊢ ¬ le1 r0 ( ( List.orderedInsert le1 r0 r ) . get n )
use n h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : 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 n I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : n < orderedInsertPos le1 r r0 htake : ( 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 hn I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : n < orderedInsertPos le1 r r0 htake : ( List.orderedInsert le1 r0 r ) . get n ∈ List.take (↑ ( orderedInsertPos le1 r r0 ) ) r ⊢ ¬ le1 r0 ( ( List.orderedInsert le1 r0 r ) . get n ) I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : n < orderedInsertPos le1 r r0 htake : ( 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_take I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : n < orderedInsertPos le1 r r0 htake : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : n < orderedInsertPos le1 r r0 htake : ( 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 htake I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I r : List I n : Fin ( List.orderedInsert le1 r0 r ) . length hn : n < orderedInsertPos le1 r r0 htake : ( 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 htake All 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 ) := by I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ 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 ) hx I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r0 ∈ List.take (↑ ( orderedInsertPos le1 r r0 ) . succ ) ( List.orderedInsert le1 r0 r ) hy I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r . get n ∈ List.drop (↑ ( orderedInsertPos le1 r r0 ) . succ ) ( List.orderedInsert le1 r0 r )
· hx I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r0 ∈ List.take (↑ ( orderedInsertPos le1 r r0 ) . succ ) ( List.orderedInsert le1 r0 r ) rw [ orderedInsertPos_succ_take_orderedInsert hx I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r0 ∈ List.takeWhile (fun b => decide ¬ le1 r0 b ) r ++ [ r0 ] hx I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r0 ∈ List.takeWhile (fun b => decide ¬ le1 r0 b ) r ++ [ r0 ] ] hx I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r0 ∈ List.takeWhile (fun b => decide ¬ le1 r0 b ) r ++ [ r0 ]
simp All goals completed! 🐙
· hy I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r . get n ∈ List.drop (↑ ( orderedInsertPos le1 r r0 ) . succ ) ( List.orderedInsert le1 r0 r ) rw [ ← orderedInsertPos_drop_eq_orderedInsert hy I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r . get n ∈ List.drop (↑ ( orderedInsertPos le1 r r0 ) ) r hy I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r . get n ∈ List.drop (↑ ( orderedInsertPos le1 r r0 ) ) r ] hy I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r . get n ∈ List.drop (↑ ( orderedInsertPos le1 r r0 ) ) r
refine List.mem_drop_iff_getElem . mpr ? _ hy I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ 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 ) . val h I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ 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 := by I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn : ¬ ↑ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ le1 r0 ( r . get n ) h I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn✝ : ¬ ↑ 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
omega h I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn✝ : ¬ ↑ 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 h I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn✝ : ¬ ↑ 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 hn h I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn✝ : ¬ ↑ 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
congr h.e_i I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hs : List.Pairwise le1 r n : Fin r . length hn✝ : ¬ ↑ 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
omega All 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 ) := by I : Type le1 : I → I → Prop inst✝ : 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 )
conv_lhs => simp only [ List.orderedInsert_eq_take_drop ] I : Type le1 : I → I → Prop inst✝ : 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.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_length I : Type le1 : I → I → Prop inst✝ : 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.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 ) hk I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ i < ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length I : Type le1 : I → I → Prop inst✝ : 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.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 ) hk I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ i < ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ] I : Type le1 : I → I → Prop inst✝ : 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.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 ) hk I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ i < ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length
· I : Type le1 : I → I → Prop inst✝ : 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.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 : Type le1 : I → I → Prop inst✝ : 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.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 1 e_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . eraseIdx i = List.takeWhile (fun b => decide ¬ le1 r0 b ) ( r . eraseIdx i ) e_a I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ r0 :: List.dropWhile (fun b => decide ¬ le1 r0 b ) r = r0 :: List.dropWhile (fun b => decide ¬ le1 r0 b ) ( r . eraseIdx i )
· e_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . eraseIdx i = List.takeWhile (fun b => decide ¬ le1 r0 b ) ( r . eraseIdx i ) rw [ takeWile_eraseIdx e_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . eraseIdx i = ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . eraseIdx i e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i ) e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i ) ] e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i )
exact hr All goals completed! 🐙
· e_a I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ r0 :: List.dropWhile (fun b => decide ¬ le1 r0 b ) r = r0 :: List.dropWhile (fun b => decide ¬ le1 r0 b ) ( r . eraseIdx i ) rw [ dropWile_eraseIdx e_a I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ 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 ) r e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i ) e_a I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ 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 ) r e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i ) ] e_a I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ 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 ) r e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i )
simp only [ orderedInsertPos , decide_not ] at hi e_a I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 ) r e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( 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 := by I : Type le1 : I → I → Prop inst✝ : 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 ) e_a I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 hi' : ¬ ( 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 ) r e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i ) omega e_a I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 hi' : ¬ ( 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 ) r e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i ) e_a I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 hi' : ¬ ( 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 ) r e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( 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.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( 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_1 All goals completed! 🐙
· hk I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ i < ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length exact hi All 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 ) := by I : Type le1 : I → I → Prop inst✝ : 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 i . succ = List.orderedInsert le1 r0 ( r . eraseIdx i )
conv_lhs => simp only [ List.orderedInsert_eq_take_drop ] I : Type le1 : I → I → Prop inst✝ : 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.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_le I : Type le1 : I → I → Prop inst✝ : 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.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 ) hk I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ i . succ I : Type le1 : I → I → Prop inst✝ : 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.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 ) hk I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ i . succ ] I : Type le1 : I → I → Prop inst✝ : 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.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 ) hk I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ i . succ
· I : Type le1 : I → I → Prop inst✝ : 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.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 : Type le1 : I → I → Prop inst✝ : 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.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 1 e_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r = List.takeWhile (fun b => decide ¬ le1 r0 b ) ( r . eraseIdx i ) e_a I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ( 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_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r = List.takeWhile (fun b => decide ¬ le1 r0 b ) ( r . eraseIdx i ) rw [ takeWile_eraseIdx , e_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r = ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . eraseIdx i e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i ) e_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ i e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i ) List.eraseIdx_of_length_le e_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r = List.takeWhile (fun b => decide ¬ le1 r0 b ) r e_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ i e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i ) e_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ i e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i ) ] e_a I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ i e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i )
simp only [ orderedInsertPos , decide_not ] at hi e_a I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 ≤ i e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i )
simp only [ decide_not ] e_a I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ 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 ≤ i e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i )
omega e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ∀ ( i j : Fin r . length ), i < j → ¬ le1 r0 ( r . get j ) → ¬ le1 r0 ( r . get i )
exact hr All goals completed! 🐙
· e_a I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ( 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_a I : Type le1 : I → I → Prop inst✝ : 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 ) ⊢ ( 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 := by I : Type le1 : I → I → Prop inst✝ : 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 i . succ = List.orderedInsert le1 r0 ( r . eraseIdx i ) e_a I : Type le1 : I → I → Prop inst✝ : 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 ) 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 hi I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ hi : ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ i hr : ∀ ( 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 + 1 e_a I : Type le1 : I → I → Prop inst✝ : 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 ) 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 )
omega e_a I : Type le1 : I → I → Prop inst✝ : 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 ) 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_a I : Type le1 : I → I → Prop inst✝ : 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 ) 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 [ hn e_a I : Type le1 : I → I → Prop inst✝ : 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 ) 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_a I : Type le1 : I → I → Prop inst✝ : 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 ) 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_a I : Type le1 : I → I → Prop inst✝ : 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 ) 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_a I : Type le1 : I → I → Prop inst✝ : 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 ) 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_a I : Type le1 : I → I → Prop inst✝ : 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 ) 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 ) r e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) 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.hc I : Type le1 : I → I → Prop inst✝ : 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 ) 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 e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) 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_pos e_a I : Type le1 : I → I → Prop inst✝ : 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 ) 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.hc I : Type le1 : I → I → Prop inst✝ : 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 ) 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 e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) 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.hc I : Type le1 : I → I → Prop inst✝ : 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 ) 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 e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) 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.hc I : Type le1 : I → I → Prop inst✝ : 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 ) 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 e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) 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.hc I : Type le1 : I → I → Prop inst✝ : 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 ) 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 [ orderedInsertPos e_a.hc I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ hi : ↑ ⟨ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length , ⋯ ⟩ ≤ i hr : ∀ ( 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 e_a.hc I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ hi : ↑ ⟨ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length , ⋯ ⟩ ≤ i hr : ∀ ( 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 hi e_a.hc I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ hi : ↑ ⟨ ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length , ⋯ ⟩ ≤ i hr : ∀ ( 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
omega All goals completed! 🐙
· e_a.hi I : Type le1 : I → I → Prop inst✝ : 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 ) 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 hr All goals completed! 🐙
· hk I : Type le1 : I → I → Prop inst✝ : 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.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ i . succ simp only [ orderedInsertPos ] at hi hk I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I i : ℕ hi : ( List.takeWhile (fun b => decide ¬ le1 r0 b ) r ) . length ≤ i 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 ) . length ≤ i . succ
omega All 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.
@[ 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 ⟩ ) := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ 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 , ⋯ ⟩ )
simp All goals completed! 🐙
| r1 :: r => I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : 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_neq I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : 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 , ⋯ ⟩ ) hij I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : n . succ < ( r0 :: r1 :: r ) . length ⊢ 0 ≠ ⟨ n + 1 , hn ⟩ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : 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 , ⋯ ⟩ ) hij I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : n . succ < ( r0 :: r1 :: r ) . length ⊢ 0 ≠ ⟨ n + 1 , hn ⟩ ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : 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 , ⋯ ⟩ ) hij I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : 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 , ⋯ ⟩ ) hij I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : n . succ < ( r0 :: r1 :: r ) . length ⊢ 0 ≠ ⟨ n + 1 , hn ⟩
rfl hij I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I n : ℕ r1 : I r : List I hn : n . succ < ( r0 :: r1 :: r ) . length ⊢ 0 ≠ ⟨ n + 1 , hn ⟩
exact ne_of_beq_false rfl All 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 ⟩ ) := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length ⊢ ( orderedInsertEquiv le1 r r0 ) n . succ = Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ n , ⋯ ⟩ )
simp only [ orderedInsertEquiv , Equiv.trans_apply ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin [ ] . length ⊢ ( Fin.castOrderIso ⋯ ) . symm ( ( finExtractOne ⟨ ↑ ( orderedInsertPos le1 [ ] r0 ) , ⋯ ⟩ ) . symm ( ( finExtractOne 0 ) n . succ ) ) =
Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 [ ] r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ n , ⋯ ⟩ )
simp All goals completed! 🐙
| r1 :: r => I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : 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_neq I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : 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 ) hij I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : Fin ( r1 :: r ) . length ⊢ 0 ≠ n . succ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : 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 ) hij I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : Fin ( r1 :: r ) . length ⊢ 0 ≠ n . succ ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : 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 ) hij I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : Fin ( r1 :: r ) . length ⊢ 0 ≠ n . succ
simp only [ orderedInsertPos , decide_not , Nat.succ_eq_add_one ,
finExtractOne_symm_inr_apply ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : 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 ) hij I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : Fin ( r1 :: r ) . length ⊢ 0 ≠ n . succ
rfl hij I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r✝ : List I r0 : I r1 : I r : List I n : Fin ( r1 :: r ) . length ⊢ 0 ≠ n . succ
exact ne_of_beq_false rfl All 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : ( orderedInsertEquiv le1 r r0 ) n . succ < ( orderedInsertEquiv le1 r r0 ) m . succ ⊢ n < m
rw [ orderedInsertEquiv_fin_succ , I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ n , ⋯ ⟩ ) < ( orderedInsertEquiv le1 r r0 ) m . succ ⊢ n < m I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : ↑ ( Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ n , ⋯ ⟩ ) ) <
↑ ( Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ m , ⋯ ⟩ ) ) ⊢ n < m orderedInsertEquiv_fin_succ , I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ n , ⋯ ⟩ ) <
Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ m , ⋯ ⟩ ) ⊢ n < m I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : ↑ ( Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ n , ⋯ ⟩ ) ) <
↑ ( Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ m , ⋯ ⟩ ) ) ⊢ n < m Fin.lt_def I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : ↑ ( Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ n , ⋯ ⟩ ) ) <
↑ ( Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ m , ⋯ ⟩ ) ) ⊢ n < m I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : ↑ ( Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ n , ⋯ ⟩ ) ) <
↑ ( Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ ↑ m , ⋯ ⟩ ) ) ⊢ n < m ] at hx I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : ↑ ( 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 hx I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove n < ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove m ⊢ n < m
rwa [ Fin.succAbove_lt_succAbove_iff I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : n < m ⊢ n < m ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : Fin r . length m : Fin r . length hx : n < m ⊢ n < m at hx lemma orderedInsertEquiv_congr { α : Type } { r : α → α → Prop } [ DecidableRel r ] ( a : α )
( l l' : List α ) ( h : l = l' ) :
orderedInsertEquiv r l a = ( Fin.castOrderIso ( by n : ℕ α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 ( by n : ℕ α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α l' : List α h : l = l' ⊢ orderedInsertEquiv r l a = ( Fin.castOrderIso ⋯ ) . trans ( ( orderedInsertEquiv r l' a ) . trans ( Fin.castOrderIso ⋯ ) . toEquiv )
subst h α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α ⊢ orderedInsertEquiv r l a = ( Fin.castOrderIso ⋯ ) . trans ( ( orderedInsertEquiv r l a ) . trans ( Fin.castOrderIso ⋯ ) . toEquiv )
rfl All 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 ) := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( r0 :: r ) . get = ( List.orderedInsert le1 r0 r ) . get ∘ ⇑ ( orderedInsertEquiv le1 r r0 )
funext x I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length h : 0 < ( r0 :: r ) . length ⊢ ( r0 :: r ) . get ⟨ 0 , h ⟩ = ( ( List.orderedInsert le1 r0 r ) . get ∘ ⇑ ( orderedInsertEquiv le1 r r0 ) ) ⟨ 0 , h ⟩
simp All goals completed! 🐙
| ⟨ Nat.succ n , h ⟩ => I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length ⊢ r [ n ] = ( List.orderedInsert le1 r0 r ) [ ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n + 1 , h ⟩ ) ]
rw [ orderedInsertEquiv_succ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length ⊢ r [ n ] = ( List.orderedInsert le1 r0 r ) [ ↑ ( Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ n , ⋯ ⟩ ) ) ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length ⊢ r [ n ] = ( List.orderedInsert le1 r0 r ) [ ↑ ( Fin.cast ⋯ ( ⟨ ↑ ( orderedInsertPos le1 r r0 ) , ⋯ ⟩ . succAbove ⟨ n , ⋯ ⟩ ) ) ] ] I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ 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 ) pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r [ n ] = ( List.orderedInsert le1 r0 r ) [ ↑ ( if n < ↑ ( orderedInsertPos le1 r r0 ) then ⟨ n , ⋯ ⟩ else ⟨ n + 1 , ⋯ ⟩ ) ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) ⊢ r [ n ] = ( List.orderedInsert le1 r0 r ) [ ↑ ( if n < ↑ ( orderedInsertPos le1 r r0 ) then ⟨ n , ⋯ ⟩ else ⟨ n + 1 , ⋯ ⟩ ) ]
· pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : 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! 🐙
· neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ 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 ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ 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_append neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ 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 ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ 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 ] ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( r0 :: r ) . get = ( List.orderedInsert le1 r0 r ) . get ∘ ⇑ ( orderedInsertEquiv le1 r r0 ) neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ 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 hn I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length ≤ n ⊢ ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ 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 ]
omega neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ 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 ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ 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 ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( r0 :: r ) . get = ( List.orderedInsert le1 r0 r ) . get ∘ ⇑ ( orderedInsertEquiv le1 r r0 ) neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 ⊢ 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 hn I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length hn : ( 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 + 1 neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 ⊢ r [ n ] =
( r0 ::
List.dropWhile (fun b => ! decide ( le1 r0 b ) ) r ) [ n + 1 - ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length ]
omega neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 ⊢ r [ n ] =
( r0 ::
List.dropWhile (fun b => ! decide ( le1 r0 b ) ) r ) [ n + 1 - ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 ⊢ 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 ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 ⊢ 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 | r [ r . length - ( List.dropWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length +
( n - ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length ) ]
congr neg.e_i I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 ⊢ 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( r0 :: r ) . get = ( List.orderedInsert le1 r0 r ) . get ∘ ⇑ ( orderedInsertEquiv le1 r r0 ) neg.e_i I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 hr : 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_append I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 ⊢ r . length = ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ++ List.dropWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 ⊢ r . length = ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ++ List.dropWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length neg.e_i I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 hr : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 ⊢ r . length = ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ++ List.dropWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length neg.e_i I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 hr : 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 )
congr I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 ⊢ r = List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ++ List.dropWhile (fun b => ! decide ( le1 r0 b ) ) r neg.e_i I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 hr : 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_i I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 hr : 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_i I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 hr : 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_i I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : Fin ( r0 :: r ) . length n : ℕ h : n . succ < ( r0 :: r ) . length hn : ¬ n < ↑ ( orderedInsertPos le1 r r0 ) hn' : ¬ n + 1 < ( List.takeWhile (fun b => ! decide ( le1 r0 b ) ) r ) . length 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 hr : 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 )
omega All 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( r0 :: r ) . get ∘ ⇑ ( orderedInsertEquiv le1 r r0 ) . symm = ( List.orderedInsert le1 r0 r ) . get
funext x I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I x : 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 , by n : ℕ I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ 0 < r . length + 1 simp All goals completed! 🐙 ⟩ ) = r := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 ) ) := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ hn : n . succ < ( 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 ) ⟨ n . succ , hn ⟩ ) =
List.orderedInsert le1 r0 ( r . eraseIdx n )
induction r with
| nil => nil I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ hn : n . succ < [ r0 ] . length hr : ∀ ( 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 hn All goals completed! 🐙
| cons r1 r ih => cons I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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_succ cons I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 ) cons I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 ) ] cons I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 ] cons I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 ) pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 ) neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 )
· pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 ] pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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' hr pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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! 🐙
· neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 _ hr neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r0 : I n : ℕ r1 : I r : List I ih : ∀ ( 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 ) . length hr : ∀ ( 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
omega All 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 ) ) := by I : Type le1 : I → I → Prop inst✝ : 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 )
exact orderedInsert_eraseIdx_orderedInsertEquiv_succ le1 r r0 n . val ( Nat.succ_lt_succ n . isLt ) hr All 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 ( by n : ℕ I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i ⊢ l . length + 1 = ( List.map (fun i => i . fst ) l ) . length + 1 simp All goals completed! 🐙 ) ) . toEquiv . trans
( ( orderedInsertEquiv le1 ( List.map ( fun i => i . 1 ) l ) i ) . trans
( Fin.castOrderIso ( by n : ℕ I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : 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 ) := by I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : 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 x I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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_zero I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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_succ I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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.succAbove I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : 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 , ⋯ ⟩ )
split isTrue I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : Fin ( l . length + 1 ) n : ℕ h0 : n . succ < l . length + 1 h✝ : n < ↑ ( orderedInsertPos le1 ( List.map (fun i => i . fst ) l ) i ) ⊢ ↑ ⟨ n , ⋯ ⟩ = ↑ ⟨ n , ⋯ ⟩ isFalse I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : Fin ( l . length + 1 ) n : ℕ h0 : n . succ < l . length + 1 h✝ : ¬ n < ↑ ( orderedInsertPos le1 ( List.map (fun i => i . fst ) l ) i ) ⊢ ↑ ⟨ n + 1 , ⋯ ⟩ = ↑ ⟨ n + 1 , ⋯ ⟩ <;> isTrue I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : Fin ( l . length + 1 ) n : ℕ h0 : n . succ < l . length + 1 h✝ : n < ↑ ( orderedInsertPos le1 ( List.map (fun i => i . fst ) l ) i ) ⊢ ↑ ⟨ n , ⋯ ⟩ = ↑ ⟨ n , ⋯ ⟩ isFalse I : Type f : I → Type le1 : I → I → Prop inst✝ : DecidableRel le1 l : List (( i : I ) × f i ) i : I a : f i x : Fin ( l . length + 1 ) n : ℕ h0 : n . succ < l . length + 1 h✝ : ¬ n < ↑ ( orderedInsertPos le1 ( List.map (fun i => i . fst ) l ) i ) ⊢ ↑ ⟨ n + 1 , ⋯ ⟩ = ↑ ⟨ n + 1 , ⋯ ⟩ rfl All 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ List.orderedInsert le1 r0 r = r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0
apply List.ext_get hl I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.orderedInsert le1 r0 r ) . length = ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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₂ ⟩
· hl I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ ( List.orderedInsert le1 r0 r ) . length = ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length simp only [ List.orderedInsert_length ] hl I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ r . length + 1 = ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length
rw [ List.length_insertIdx hl I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ r . length + 1 = if ↑ ( orderedInsertPos le1 r r0 ) ≤ r . length then r . length + 1 else r . length hl I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ r . length + 1 = if ↑ ( orderedInsertPos le1 r r0 ) ≤ r . length then r . length + 1 else r . length ] hl I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : 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 ) ) ) . symm All goals completed! 🐙
intro n h1 h2 h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.orderedInsert le1 r0 r ) . length h2 : 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 ⟩ h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.orderedInsert le1 r0 r ) . length h2 : n < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length n' : 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' h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.orderedInsert le1 r0 r ) . length h2 : n < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length n' : 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 ⟩ h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.orderedInsert le1 r0 r ) . length h2 : n < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length n' : 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 ⟩ ] h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.orderedInsert le1 r0 r ) . length h2 : n < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length n' : 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 := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ List.orderedInsert le1 r0 r = r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.orderedInsert le1 r0 r ) . length h2 : n < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length n' : 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.orderedInsert le1 r0 r ) . length h2 : n < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length n' : Fin ( r . length + 1 ) hn' : ( orderedInsertEquiv le1 r r0 ) n' = ⟨ n , h1 ⟩ ⊢ n = ↑ ⟨ n , h1 ⟩ h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.orderedInsert le1 r0 r ) . length h2 : n < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length n' : 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 ⟩ ] h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.orderedInsert le1 r0 r ) . length h2 : n < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length n' : 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 ⟩ h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n : ℕ h1 : n < ( List.orderedInsert le1 r0 r ) . length h2 : n < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length n' : 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'' h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n' : Fin ( r . length + 1 ) h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) n' ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) n' ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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_get h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n' : Fin ( r . length + 1 ) h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) n' ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) n' ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ⟩ h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n' : Fin ( r . length + 1 ) h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) n' ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) n' ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ⟩ ] h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n' : Fin ( r . length + 1 ) h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) n' ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) n' ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ] h I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n' : Fin ( r . length + 1 ) h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) n' ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) n' ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n' : Fin ( r . length + 1 ) h0 : 0 < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ 0 , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ 0 , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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' h0 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ⟩ ) ]
swap I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ⟩ ) ] rfl All goals completed! 🐙
rw [ Fin.ext_iff I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 hr I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ⟩ , by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ) . length I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 [ ← hr I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ) . length I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ) . length I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 h2 All goals completed! 🐙 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ⟩ ⟩ := by I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I ⊢ List.orderedInsert le1 r0 r = r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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_iff I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 only I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 hr I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 [ hx I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn' : ( 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 ) pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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 , ⋯ ⟩ ) ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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 , ⋯ ⟩ ) ]
· pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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 ] pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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_lt pos I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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.hn I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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.hn I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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! 🐙
· neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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 ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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_gt neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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.hn I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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 neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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.hn I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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 ] neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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.hn I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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
· neg I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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 ] rfl All goals completed! 🐙
· neg.hn I : Type le1 : I → I → Prop inst✝ : DecidableRel le1 r : List I r0 : I n'✝ : Fin ( r . length + 1 ) n' : ℕ h0 : n' . succ < r . length + 1 h1 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( List.orderedInsert le1 r0 r ) . length h2 : ↑ ( ( orderedInsertEquiv le1 r r0 ) ⟨ n' . succ , h0 ⟩ ) < ( r . insertIdx (↑ ( orderedInsertPos le1 r r0 ) ) r0 ) . length hn'✝ : ( 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 omega All 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
| [ ] => α : Type r : α → α → Prop inst✝ : DecidableRel r ⊢ [ ] . get ∘ ⇑ ( insertionSortEquiv r [ ] ) . symm = ( List.insertionSort r [ ] ) . get by α : Type r : α → α → Prop inst✝ : DecidableRel r ⊢ [ ] . get ∘ ⇑ ( insertionSortEquiv r [ ] ) . symm = ( List.insertionSort r [ ] ) . get rfl All goals completed! 🐙
| a :: l => α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α ⊢ ( a :: l ) . get ∘ ⇑ ( insertionSortEquiv r ( a :: l ) ) . symm = ( List.insertionSort r ( a :: l ) ) . get by α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α ⊢ ( a :: l ) . get ∘ ⇑ ( insertionSortEquiv r ( a :: l ) ) . symm = ( List.insertionSort r ( a :: l ) ) . get
rw [ insertionSortEquiv α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α ⊢ ( a :: l ) . get ∘ ⇑ ( ( equivCons ( insertionSortEquiv r l ) ) . trans ( orderedInsertEquiv r ( List.insertionSort r l ) a ) ) . symm =
( List.insertionSort r ( a :: l ) ) . get α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α ⊢ ( a :: l ) . get ∘ ⇑ ( ( equivCons ( insertionSortEquiv r l ) ) . trans ( orderedInsertEquiv r ( List.insertionSort r l ) a ) ) . symm =
( List.insertionSort r ( a :: l ) ) . get ] α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 = _ α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α ⊢ ( a :: l ) . get ∘ ⇑ ( insertionSortEquiv r ( a :: l ) ) . symm = ( List.insertionSort r ( a :: l ) ) . get α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 ⟩ => α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α x : Fin ( List.insertionSort r l ) . length . succ h : 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 ⟩ α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 All goals completed! 🐙 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 ⟩ => α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α x✝ : Fin ( List.insertionSort r l ) . length . succ x : ℕ 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 ⟩ α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 _ α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α x✝ : Fin ( List.insertionSort r l ) . length . succ x : ℕ 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 , ⋯ ⟩ α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α x✝ : Fin ( List.insertionSort r l ) . length . succ x : ℕ 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 , ⋯ ⟩ α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α x✝ : Fin ( List.insertionSort r l ) . length . succ x : ℕ 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 , ⋯ ⟩ α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 ] α : Type r : α → α → Prop inst✝ : DecidableRel r a : α l : List α x✝ : Fin ( List.insertionSort r l ) . length . succ x : ℕ 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 , ⋯ ⟩ α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 , α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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 ] α : Type r : α → α → Prop inst✝ : DecidableRel r a : α 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
rfl All goals completed! 🐙 lemma insertionSortEquiv_congr { α : Type } { r : α → α → Prop } [ DecidableRel r ] ( l l' : List α )
( h : l = l' ) : insertionSortEquiv r l = ( Fin.castOrderIso ( by n : ℕ α : Type r : α → α → Prop inst✝ : DecidableRel r l : List α l' : List α h : l = l' ⊢ l . length = l' . length simp [ h ] All goals completed! 🐙 ) ) . toEquiv . trans
( ( insertionSortEquiv r l' ) . trans ( Fin.castOrderIso ( by n : ℕ α : Type r : α → α → Prop inst✝ : DecidableRel r l : List α l' : List α h : l = l' ⊢ ( List.insertionSort r l' ) . length = ( List.insertionSort r l ) . length simp [ h ] All goals completed! 🐙 ) ) . toEquiv ) := by α : Type r : α → α → Prop inst✝ : DecidableRel r l : List α l' : List α h : l = l' ⊢ insertionSortEquiv r l = ( Fin.castOrderIso ⋯ ) . trans ( ( insertionSortEquiv r l' ) . trans ( Fin.castOrderIso ⋯ ) . toEquiv )
subst h α : Type r : α → α → Prop inst✝ : DecidableRel r l : List α ⊢ insertionSortEquiv r l = ( Fin.castOrderIso ⋯ ) . trans ( ( insertionSortEquiv r l ) . trans ( Fin.castOrderIso ⋯ ) . toEquiv )
rfl All 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 ( by n : ℕ α : Type r : α → α → Prop inst✝ : DecidableRel r l : 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 ( by n : ℕ α : Type r : α → α → Prop inst✝ : DecidableRel r l : List α l' : List α h : l = l' i : Fin l . length ⊢ l . length = l' . length simp [ h ] All goals completed! 🐙 ) i ) ) := by α : Type r : α → α → Prop inst✝ : DecidableRel r l : 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 α : Type r : α → α → Prop inst✝ : DecidableRel r l : 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 ) ) α : Type r : α → α → Prop inst✝ : DecidableRel r l : 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 ) ) ] α : Type r : α → α → Prop inst✝ : DecidableRel r l : 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 ) )
simp All 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 α : Type r : α → α → Prop inst✝ : DecidableRel r l : List α ⊢ ( List.insertionSort r l ) . get ∘ ⇑ ( insertionSortEquiv r l ) = l . get
funext x α : Type r : α → α → Prop inst✝ : DecidableRel r l : 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 α : Type r : α → α → Prop inst✝ : DecidableRel r l : List α ⊢ List.insertionSort r l = List.ofFn ( l . get ∘ ⇑ ( insertionSortEquiv r l ) . symm )
rw [ insertionSortEquiv_get ( r := r ) , α : Type r : α → α → Prop inst✝ : DecidableRel r l : List α ⊢ List.insertionSort r l = List.ofFn ( List.insertionSort r l ) . get All goals completed! 🐙 List.ofFn_get α : Type r : α → α → Prop inst✝ : DecidableRel r l : List α ⊢ List.insertionSort r l = List.insertionSort r l All 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' => α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α hi : 0 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α hi : 0 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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 ] α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α hi : 0 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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' α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α hi : 0 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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' α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α hi : 0 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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' α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α hi : 0 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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 ⟩ ) α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α hi : 0 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α hi : 0 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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 ⟩ ) α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α hi : 0 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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 ⟩ ) ] α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α hi : 0 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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 ⟩ )
simp All goals completed! 🐙
| a :: as , ⟨ i + 1 , hi ⟩ , ⟨ j + 1 , hj ⟩ , hij , hij' => α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α i : ℕ hi : i + 1 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α i : ℕ hi : i + 1 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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' α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α i : ℕ hi : i + 1 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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 α : Type r : α → α → Prop inst✝ : DecidableRel r a : α as : List α i : ℕ hi : i + 1 < ( a :: as ) . length j : ℕ hj : j + 1 < ( a :: as ) . length hij : ⟨ 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 hij All 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` file expose ] 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 := by I : Type l : List I i : 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 . isLt lemma 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 . isLt lemma eraseIdx_cons_length { I : Type } ( a : I ) ( l : List I ) ( i : Fin ( a :: l ) . length ) :
( List.eraseIdx ( a :: l ) i ) . length = l . length := by I : Type a : I l : List I i : 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 := by I : Type l : List I i : Fin l . length ⊢ ( l . eraseIdx ↑ i ) . get = l . get ∘ Fin.cast ⋯ ∘ ( Fin.cast ⋯ i ) . succAbove
ext x I : Type l : List I i : Fin l . length x : 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 : Type l : List I i : Fin l . length x : 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 : Type l : List I i : Fin l . length x : 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 ) ) i pos I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi : 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 ) ] neg I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi : ¬ 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 ) ]
· pos I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi : 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 ] pos I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi : x . castSucc < Fin.cast ⋯ i ⊢ ∀ ( h : ↑ i ≤ ↑ x ), l [ ↑ x + 1 ] = l [ ↑ x ]
intro h pos I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi : x . castSucc < Fin.cast ⋯ i h : ↑ i ≤ ↑ x ⊢ l [ ↑ x + 1 ] = l [ ↑ x ]
rw [ Fin.lt_def pos I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi : ↑ x . castSucc < ↑ ( Fin.cast ⋯ i ) h : ↑ i ≤ ↑ x ⊢ l [ ↑ x + 1 ] = l [ ↑ x ] pos I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi : ↑ x . castSucc < ↑ ( Fin.cast ⋯ i ) h : ↑ i ≤ ↑ x ⊢ l [ ↑ x + 1 ] = l [ ↑ x ] ] at hi pos I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi : ↑ x . castSucc < ↑ ( Fin.cast ⋯ i ) h : ↑ i ≤ ↑ x ⊢ l [ ↑ x + 1 ] = l [ ↑ x ]
simp_all only [ Fin.val_castSucc , Fin.val_cast ] pos I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length h : ↑ i ≤ ↑ x hi : ↑ x < ↑ i ⊢ l [ ↑ x + 1 ] = l [ ↑ x ]
omega All goals completed! 🐙
· neg I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi : ¬ 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 ] neg I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi : ¬ x . castSucc < Fin.cast ⋯ i ⊢ (if h' : ↑ x < ↑ i then l [ ↑ x ] else l [ ↑ x + 1 ] ) = l [ ↑ x + 1 ]
rw [ Fin.lt_def neg I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi✝ : ¬ x . castSucc < Fin.cast ⋯ i hi : ¬ ↑ x . castSucc < ↑ ( Fin.cast ⋯ i ) ⊢ (if h' : ↑ x < ↑ i then l [ ↑ x ] else l [ ↑ x + 1 ] ) = l [ ↑ x + 1 ] neg I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi✝ : ¬ x . castSucc < Fin.cast ⋯ i hi : ¬ ↑ x . castSucc < ↑ ( Fin.cast ⋯ i ) ⊢ (if h' : ↑ x < ↑ i then l [ ↑ x ] else l [ ↑ x + 1 ] ) = l [ ↑ x + 1 ] ] at hi neg I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi✝ : ¬ x . castSucc < Fin.cast ⋯ i hi : ¬ ↑ 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 hi neg I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi✝ : ¬ x . castSucc < Fin.cast ⋯ i hi : ↑ i ≤ ↑ x ⊢ (if h' : ↑ x < ↑ i then l [ ↑ x ] else l [ ↑ x + 1 ] ) = l [ ↑ x + 1 ]
have hn : ¬ x . val < i . val := by I : Type l : List I i : Fin l . length ⊢ ( l . eraseIdx ↑ i ) . get = l . get ∘ Fin.cast ⋯ ∘ ( Fin.cast ⋯ i ) . succAbove neg I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi✝ : ¬ x . castSucc < Fin.cast ⋯ i hi : ↑ i ≤ ↑ x hn : ¬ ↑ x < ↑ i ⊢ (if h' : ↑ x < ↑ i then l [ ↑ x ] else l [ ↑ x + 1 ] ) = l [ ↑ x + 1 ] omega neg I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi✝ : ¬ x . castSucc < Fin.cast ⋯ i hi : ↑ i ≤ ↑ x hn : ¬ ↑ x < ↑ i ⊢ (if h' : ↑ x < ↑ i then l [ ↑ x ] else l [ ↑ x + 1 ] ) = l [ ↑ x + 1 ] neg I : Type l : List I i : Fin l . length x : Fin ( l . eraseIdx ↑ i ) . length hi✝ : ¬ x . castSucc < Fin.cast ⋯ i hi : ↑ i ≤ ↑ x hn : ¬ ↑ 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 : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 x✝ : 0 < [ ] . length ⊢ ( List.insertionSort le1 [ ] ) . eraseIdx ↑ ( ( insertionSortEquiv le1 [ ] ) ⟨ 0 , x✝ ⟩ ) = List.insertionSort le1 ( [ ] . eraseIdx 0 ) by I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 x✝ : 0 < [ ] . length ⊢ ( List.insertionSort le1 [ ] ) . eraseIdx ↑ ( ( insertionSortEquiv le1 [ ] ) ⟨ 0 , x✝ ⟩ ) = List.insertionSort le1 ( [ ] . eraseIdx 0 ) rfl All goals completed! 🐙
| 0 , ( r0 :: r ) , hn => I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hn : 0 < ( r0 :: r ) . length ⊢ ( List.insertionSort le1 ( r0 :: r ) ) . eraseIdx ↑ ( ( insertionSortEquiv le1 ( r0 :: r ) ) ⟨ 0 , hn ⟩ ) =
List.insertionSort le1 ( ( r0 :: r ) . eraseIdx 0 ) by I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 r0 : I r : List I hn : 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 : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ hn : n . succ < [ ] . length ⊢ ( List.insertionSort le1 [ ] ) . eraseIdx ↑ ( ( insertionSortEquiv le1 [ ] ) ⟨ n . succ , hn ⟩ ) =
List.insertionSort le1 ( [ ] . eraseIdx n . succ ) by I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ hn : n . succ < [ ] . length ⊢ ( List.insertionSort le1 [ ] ) . eraseIdx ↑ ( ( insertionSortEquiv le1 [ ] ) ⟨ n . succ , hn ⟩ ) =
List.insertionSort le1 ( [ ] . eraseIdx n . succ ) rfl All goals completed! 🐙
| Nat.succ n , ( r0 :: r ) , hn => I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : 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 ) by I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : 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 : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : 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 , by I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length ⊢ n < r . length I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 hn All goals completed! 🐙 I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 [ hOr I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 )
congr e_a I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 hn I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn✝ : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 ) . length j : Fin ( List.insertionSort le1 r ) . length hij : i < j hn : ¬ 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 ) hij I : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn✝ : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 ) . length j : Fin ( List.insertionSort le1 r ) . length hij : i < j hn : ¬ 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 : Type le1 : I → I → Prop inst✝² : DecidableRel le1 inst✝¹ : Std.Total le1 inst✝ : IsTrans I le1 n : ℕ r0 : I r : List I hn✝ : n . succ < ( r0 :: r ) . length hOr : (∀ ( 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 ) . length j : Fin ( List.insertionSort le1 r ) . length hij : i < j hn : ¬ 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 hn All 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. .
The element of i :: l at insertionSortMinPos.
@[ `@[expose]` has no effect outside a `module` file expose ] def insertionSortMin { α : Type } ( r : α → α → Prop ) [ DecidableRel r ] ( i : α ) ( l : List α ) :
α := ( i :: l ) . get ( insertionSortMinPos r i l )
The list remaining after dropping the element at the position determined by
insertionSortMinPos.
@[ `@[expose]` has no effect outside a `module` file expose ]
def insertionSortDropMinPos { α : Type } ( r : α → α → Prop ) [ DecidableRel r ] ( i : α ) ( l : List α ) :
List α := ( i :: l ) . eraseIdx ( insertionSortMinPos r i l )
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` file expose ] 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 := by I : Type l : List I a : I i : 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 ( by n : ℕ I : Type l : List I l' : List I a : I a' : I i : Option ( Fin l . length ) i' : Option ( Fin l' . length ) hl : l = l' ha : a = a' ⊢ l . length = l' . length rw [ hl n : ℕ I : Type l : List I l' : List I a : I a' : I i : Option ( Fin l . length ) i' : Option ( Fin l' . length ) hl : l = l' ha : a = a' ⊢ l' . length = l' . length All goals completed! 🐙 ] All goals completed! 🐙 ) ) i = i' ) :
optionEraseZ l a i = optionEraseZ l' a' i' := by I : Type l : List I l' : List I a : I a' : I i : 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 hl I : Type l : List I a : I a' : I i : 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 ha I : Type l : List I a : I i : 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 hi refl I : Type l : List I a : I i : Option ( Fin l . length ) ⊢ optionEraseZ l a i = optionEraseZ l a ( Option.map ( Fin.cast ⋯ ) i )
congr refl.e_i I : Type l : List I a : I i : Option ( Fin l . length ) ⊢ i = Option.map ( Fin.cast ⋯ ) i
simp All 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 by n : ℕ a : Fin ( n + 1 ) ⊢ a ∈ List.take 0 ( List.finRange ( n + 1 ) ) ↔ ↑ a < 0
simp All 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 by n : ℕ 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 by n : ℕ 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 < m n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 ⊢ (∃ a ∈ List.take m ( List.finRange n ) , a . succ = ⟨ i + 1 , h ⟩ ) ↔ i < m @ List.mem_map n : ℕ 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 ] n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 ⊢ (∃ a ∈ List.take m ( List.finRange n ) , a . succ = ⟨ i + 1 , h ⟩ ) ↔ i < m
apply Iff.intro mp n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 ⊢ (∃ a ∈ List.take m ( List.finRange n ) , a . succ = ⟨ i + 1 , h ⟩ ) → i < m mpr n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 ⊢ i < m → ∃ a ∈ List.take m ( List.finRange n ) , a . succ = ⟨ i + 1 , h ⟩
· mp n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 ⊢ (∃ a ∈ List.take m ( List.finRange n ) , a . succ = ⟨ i + 1 , h ⟩ ) → i < m intro h mp n : ℕ m : ℕ i : ℕ h✝ : i + 1 < n + 1 h : ∃ a ∈ List.take m ( List.finRange n ) , a . succ = ⟨ i + 1 , h✝ ⟩ ⊢ i < m
obtain ⟨ a , ha ⟩ := h mp n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 a : Fin n ha : a ∈ List.take m ( List.finRange n ) ∧ a . succ = ⟨ i + 1 , h ⟩ ⊢ i < m
rw [ mem_take_finrange n m a , mp n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 a : Fin n ha : ↑ a < m ∧ a . succ = ⟨ i + 1 , h ⟩ ⊢ i < m mp n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 a : Fin n ha : ↑ a < m ∧ ↑ a . succ = ↑ ⟨ i + 1 , h ⟩ ⊢ i < m Fin.ext_iff mp n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 a : Fin n ha : ↑ a < m ∧ ↑ a . succ = ↑ ⟨ i + 1 , h ⟩ ⊢ i < m mp n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 a : Fin n ha : ↑ a < m ∧ ↑ a . succ = ↑ ⟨ i + 1 , h ⟩ ⊢ i < m ] at ha mp n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 a : Fin n ha : ↑ a < m ∧ ↑ a . succ = ↑ ⟨ i + 1 , h ⟩ ⊢ i < m
simp_all only [ Fin.val_succ , add_left_inj ] mp n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 a : Fin n ha : ↑ a < m ∧ ↑ a = i ⊢ i < m
omega All goals completed! 🐙
· mpr n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 ⊢ i < m → ∃ a ∈ List.take m ( List.finRange n ) , a . succ = ⟨ i + 1 , h ⟩ intro h1 mpr n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 h1 : i < m ⊢ ∃ a ∈ List.take m ( List.finRange n ) , a . succ = ⟨ i + 1 , h✝ ⟩
use ⟨ i , Nat.succ_lt_succ_iff . mp h ⟩ h n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 h1 : i < m ⊢ ⟨ i , ⋯ ⟩ ∈ List.take m ( List.finRange n ) ∧ ⟨ i , ⋯ ⟩ . succ = ⟨ i + 1 , h ⟩
simp only [ Fin.succ_mk , and_true ] h n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 h1 : i < m ⊢ ⟨ i , ⋯ ⟩ ∈ List.take m ( List.finRange n )
rwa [ mem_take_finrange n m ⟨ i , Nat.succ_lt_succ_iff . mp h ⟩ h n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 h1 : i < m ⊢ ↑ ⟨ i , ⋯ ⟩ < m ] h n : ℕ m : ℕ i : ℕ h : i + 1 < n + 1 h1 : i < m ⊢ ↑ ⟨ i , ⋯ ⟩ < m