Datasets:

internlm
/

Lean-Github

Dataset card Data Studio Files Files and versions Community

Split (1)

train · 219k rows

url stringclasses 147 values	commit stringclasses 147 values	file_path stringlengths 7 101	full_name stringlengths 1 94	start stringlengths 6 10	end stringlengths 6 11	tactic stringlengths 1 11.2k	state_before stringlengths 3 2.09M	state_after stringlengths 6 2.09M
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Order.lean	Order.not_lt_of_le	[53, 1]	[61, 18]	simp [leOfOrd, cmp] at h	α : Type inst✝ : Order α x y : α h : x ≤ y cmp : compare x y = Ordering.gt ⊢ ¬y < x	α : Type inst✝ : Order α x y : α cmp : compare x y = Ordering.gt h : Ordering.gt.isLE = true ⊢ ¬y < x
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Order.lean	Order.not_lt_of_le	[53, 1]	[61, 18]	contradiction	α : Type inst✝ : Order α x y : α cmp : compare x y = Ordering.gt h : Ordering.gt.isLE = true ⊢ ¬y < x	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Order.lean	Order.le_of_lt	[63, 1]	[70, 18]	show (compare x y).isLE	α : Type inst✝ : Order α x y : α h : x < y ⊢ x ≤ y	α : Type inst✝ : Order α x y : α h : x < y ⊢ (compare x y).isLE = true
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Order.lean	Order.le_of_lt	[63, 1]	[70, 18]	simp [ltOfOrd] at h	α : Type inst✝ : Order α x y : α h : x < y ⊢ (compare x y).isLE = true	α : Type inst✝ : Order α x y : α h : compare x y = Ordering.lt ⊢ (compare x y).isLE = true
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Order.lean	Order.le_of_lt	[63, 1]	[70, 18]	match cmp : compare x y with \| .lt => decide \| .eq \| .gt => rw [cmp] at h contradiction	α : Type inst✝ : Order α x y : α h : compare x y = Ordering.lt ⊢ (compare x y).isLE = true	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Order.lean	Order.le_of_lt	[63, 1]	[70, 18]	decide	α : Type inst✝ : Order α x y : α h cmp : compare x y = Ordering.lt ⊢ Ordering.lt.isLE = true	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Order.lean	Order.le_of_lt	[63, 1]	[70, 18]	rw [cmp] at h	α : Type inst✝ : Order α x y : α h : compare x y = Ordering.lt cmp : compare x y = Ordering.gt ⊢ Ordering.gt.isLE = true	α : Type inst✝ : Order α x y : α h : Ordering.gt = Ordering.lt cmp : compare x y = Ordering.gt ⊢ Ordering.gt.isLE = true
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Order.lean	Order.le_of_lt	[63, 1]	[70, 18]	contradiction	α : Type inst✝ : Order α x y : α h : Ordering.gt = Ordering.lt cmp : compare x y = Ordering.gt ⊢ Ordering.gt.isLE = true	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	induction arr, first, i, j, fi, ij using partitionImpl.induct' with \| base arr first i j fi _ h => revert result simp [] have : i = first := Fin.eq_of_val_eq (Nat.le_antisymm (Nat.le_of_not_lt h) fi) exact this ▸ inv \| step_lt arr first i j _ _ fi _ lt _ ih => have inv : LoopInvariant arr first i.prev j last := by apply LoopInvariant.intro . intro k ik kj have ik : i.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ik cases Nat.eq_or_lt_of_le ik with \| inl ik => simp [Fin.eq_of_val_eq ik] at lt exact lt \| inr ik => exact inv.1 k ik kj . exact inv.2 . intro ij have ij : i.val ≤ j.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ij cases Nat.eq_or_lt_of_le ij with \| inl ij => simp [Fin.eq_of_val_eq ij.symm] assumption \| inr ij => exact inv.3 ij simp [] at eq apply ih inv result eq \| step_ge arr first i j _ ij fi _ _ _ ih => let swapped := arr.swap i j have sf : swapped[first] = arr[first] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_lt fi . apply Fin.ne_of_val_ne exact Nat.ne_of_lt (Nat.lt_of_lt_of_le fi ij) let result := partitionImpl swapped first i.prev j.prev (by assumption) (by assumption) subst eq simp [*] have inv : LoopInvariant swapped first i.prev j.prev last := by apply LoopInvariant.intro . intro k ik kj have ik : i.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ik cases Nat.eq_or_lt_of_le ik with \| inl ik => have : swapped[k] = arr[j] := by simp [Fin.eq_of_val_eq ik.symm] apply Vec.get_swap_left rw [this, sf] exact inv.3 (Nat.lt_of_lt_of_le (Fin.eq_of_val_eq ik.symm ▸ kj) (Nat.sub_le ..)) \| inr ik => have kj : k < j := (Nat.lt_of_lt_of_le kj (Nat.sub_le ..)) have : swapped[k] = arr[k] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt ik . apply Fin.ne_of_val_ne exact Nat.ne_of_lt kj rw [this, sf] exact inv.1 k ik kj . intro k jk kl have jk : j.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi ij)))] exact jk cases Nat.eq_or_lt_of_le jk with \| inl jk => have : swapped[k] = arr[i] := by simp [Fin.eq_of_val_eq jk.symm] apply Vec.get_swap_right rw [this, sf] assumption \| inr jk => have : swapped[k] = arr[k] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk) . apply Fin.ne_of_val_ne exact Nat.ne_of_gt jk rw [this, sf] exact inv.2 k jk kl . intro ij have : j.val - 1 < j.val := by show j.val - 1 + 1 ≤ j.val rw [Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi (by assumption)))] apply Nat.le_refl have ij : i.val ≤ j.val - 1 := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ij cases Nat.eq_or_lt_of_le ij with \| inl ij => have : swapped[j.prev] = arr[j] := by simp [ij.symm, Fin.prev] apply Vec.get_swap_left rw [this, sf] have : i < j := Nat.lt_of_le_of_lt (by assumption : i.val ≤ j.val - 1) (by assumption) exact inv.3 this \| inr ij => have : swapped[j.prev] = arr[j.prev] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt ij . apply Fin.ne_of_val_ne exact Nat.ne_of_lt (by assumption) rw [this, sf] apply inv.1 j.prev ij (by assumption) exact ih inv result (by rfl)	α : Type inst✝ : Ord α n : Nat arr : Vec α n first i j last : Fin n fi : first ≤ i ij : i ≤ j inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi ij = result ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	revert result	case base α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi : first ≤ i ij✝ : i ≤ j h : ¬first < i inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi ij✝ = result ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last	case base α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi : first ≤ i ij✝ : i ≤ j h : ¬first < i inv : LoopInvariant arr first i j last ⊢ ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i j fi ij✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	simp [*]	case base α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi : first ≤ i ij✝ : i ≤ j h : ¬first < i inv : LoopInvariant arr first i j last ⊢ ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i j fi ij✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last	case base α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi : first ≤ i ij✝ : i ≤ j h : ¬first < i inv : LoopInvariant arr first i j last ⊢ LoopInvariant arr first first j last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have : i = first := Fin.eq_of_val_eq (Nat.le_antisymm (Nat.le_of_not_lt h) fi)	case base α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi : first ≤ i ij✝ : i ≤ j h : ¬first < i inv : LoopInvariant arr first i j last ⊢ LoopInvariant arr first first j last	case base α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi : first ≤ i ij✝ : i ≤ j h : ¬first < i inv : LoopInvariant arr first i j last this : i = first ⊢ LoopInvariant arr first first j last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact this ▸ inv	case base α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi : first ≤ i ij✝ : i ≤ j h : ¬first < i inv : LoopInvariant arr first i j last this : i = first ⊢ LoopInvariant arr first first j last	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have inv : LoopInvariant arr first i.prev j last := by apply LoopInvariant.intro . intro k ik kj have ik : i.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ik cases Nat.eq_or_lt_of_le ik with \| inl ik => simp [Fin.eq_of_val_eq ik] at lt exact lt \| inr ik => exact inv.1 k ik kj . exact inv.2 . intro ij have ij : i.val ≤ j.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ij cases Nat.eq_or_lt_of_le ij with \| inl ij => simp [Fin.eq_of_val_eq ij.symm] assumption \| inr ij => exact inv.3 ij	case step_lt α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last	case step_lt α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv✝ : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result inv : LoopInvariant arr first i.prev j last ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	simp [*] at eq	case step_lt α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv✝ : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result inv : LoopInvariant arr first i.prev j last ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last	case step_lt α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv✝ : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n inv : LoopInvariant arr first i.prev j last eq : partitionImpl arr first i.prev j ⋯ ⋯ = result ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply ih inv result eq	case step_lt α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv✝ : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n inv : LoopInvariant arr first i.prev j last eq : partitionImpl arr first i.prev j ⋯ ⋯ = result ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply LoopInvariant.intro	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ LoopInvariant arr first i.prev j last	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ ∀ (k : Fin n), i.prev < k → k < j → arr[k] < arr[first] case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first] case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ i.prev < j → arr[j] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. intro k ik kj have ik : i.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ik cases Nat.eq_or_lt_of_le ik with \| inl ik => simp [Fin.eq_of_val_eq ik] at lt exact lt \| inr ik => exact inv.1 k ik kj	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ ∀ (k : Fin n), i.prev < k → k < j → arr[k] < arr[first] case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first] case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ i.prev < j → arr[j] < arr[first]	case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first] case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ i.prev < j → arr[j] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. exact inv.2	case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first] case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ i.prev < j → arr[j] < arr[first]	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ i.prev < j → arr[j] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. intro ij have ij : i.val ≤ j.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ij cases Nat.eq_or_lt_of_le ij with \| inl ij => simp [Fin.eq_of_val_eq ij.symm] assumption \| inr ij => exact inv.3 ij	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ i.prev < j → arr[j] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	intro k ik kj	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ ∀ (k : Fin n), i.prev < k → k < j → arr[k] < arr[first]	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik : i.prev < k kj : k < j ⊢ arr[k] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have ik : i.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ik	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik : i.prev < k kj : k < j ⊢ arr[k] < arr[first]	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik✝ : i.prev < k kj : k < j ik : ↑i ≤ ↑k ⊢ arr[k] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	cases Nat.eq_or_lt_of_le ik with \| inl ik => simp [Fin.eq_of_val_eq ik] at lt exact lt \| inr ik => exact inv.1 k ik kj	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik✝ : i.prev < k kj : k < j ik : ↑i ≤ ↑k ⊢ arr[k] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik : i.prev < k kj : k < j ⊢ ↑i ≤ ↑k	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik : i.prev < k kj : k < j ⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑k
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact ik	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik : i.prev < k kj : k < j ⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑k	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	simp [Fin.eq_of_val_eq ik] at lt	case inv₁.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik✝¹ : i.prev < k kj : k < j ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k ⊢ arr[k] < arr[first]	case inv₁.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik✝¹ : i.prev < k kj : k < j ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k lt : arr[k] < arr[first] ⊢ arr[k] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact lt	case inv₁.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik✝¹ : i.prev < k kj : k < j ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k lt : arr[k] < arr[first] ⊢ arr[k] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact inv.1 k ik kj	case inv₁.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result k : Fin n ik✝¹ : i.prev < k kj : k < j ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k ⊢ arr[k] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact inv.2	case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	intro ij	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ⊢ i.prev < j → arr[j] < arr[first]	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ij : i.prev < j ⊢ arr[j] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have ij : i.val ≤ j.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ij	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ij : i.prev < j ⊢ arr[j] < arr[first]	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝¹ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝¹ = result ij✝ : i.prev < j ij : ↑i ≤ ↑j ⊢ arr[j] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	cases Nat.eq_or_lt_of_le ij with \| inl ij => simp [Fin.eq_of_val_eq ij.symm] assumption \| inr ij => exact inv.3 ij	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝¹ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝¹ = result ij✝ : i.prev < j ij : ↑i ≤ ↑j ⊢ arr[j] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ij : i.prev < j ⊢ ↑i ≤ ↑j	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ij : i.prev < j ⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑j
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact ij	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝ = result ij : i.prev < j ⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑j	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	simp [Fin.eq_of_val_eq ij.symm]	case inv₃.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝² : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝² = result ij✝¹ : i.prev < j ij✝ : ↑i ≤ ↑j ij : ↑i = ↑j ⊢ arr[j] < arr[first]	case inv₃.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝² : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝² = result ij✝¹ : i.prev < j ij✝ : ↑i ≤ ↑j ij : ↑i = ↑j ⊢ arr[i] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	assumption	case inv₃.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝² : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝² = result ij✝¹ : i.prev < j ij✝ : ↑i ≤ ↑j ij : ↑i = ↑j ⊢ arr[i] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact inv.3 ij	case inv₃.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝² : i ≤ j fi : first < i x✝¹ : ↑first ≤ ↑i - 1 lt : arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j ih : LoopInvariant arr first i.prev j last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n), partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij✝² = result ij✝¹ : i.prev < j ij✝ : ↑i ≤ ↑j ij : ↑i < ↑j ⊢ arr[j] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	let swapped := arr.swap i j	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have sf : swapped[first] = arr[first] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_lt fi . apply Fin.ne_of_val_ne exact Nat.ne_of_lt (Nat.lt_of_lt_of_le fi ij)	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	let result := partitionImpl swapped first i.prev j.prev (by assumption) (by assumption)	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] ⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result✝ : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result✝ swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ LoopInvariant result✝.snd first first ⟨↑result✝.fst.val, ⋯⟩ last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	subst eq	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result✝ : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result✝ swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ LoopInvariant result✝.snd first first ⟨↑result✝.fst.val, ⋯⟩ last	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ LoopInvariant (partitionImpl arr first i j fi✝ ij).snd first first ⟨↑(partitionImpl arr first i j fi✝ ij).fst.val, ⋯⟩ last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	simp [*]	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ LoopInvariant (partitionImpl arr first i j fi✝ ij).snd first first ⟨↑(partitionImpl arr first i j fi✝ ij).fst.val, ⋯⟩ last	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ LoopInvariant (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).snd first first (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).1.val last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have inv : LoopInvariant swapped first i.prev j.prev last := by apply LoopInvariant.intro . intro k ik kj have ik : i.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ik cases Nat.eq_or_lt_of_le ik with \| inl ik => have : swapped[k] = arr[j] := by simp [Fin.eq_of_val_eq ik.symm] apply Vec.get_swap_left rw [this, sf] exact inv.3 (Nat.lt_of_lt_of_le (Fin.eq_of_val_eq ik.symm ▸ kj) (Nat.sub_le ..)) \| inr ik => have kj : k < j := (Nat.lt_of_lt_of_le kj (Nat.sub_le ..)) have : swapped[k] = arr[k] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt ik . apply Fin.ne_of_val_ne exact Nat.ne_of_lt kj rw [this, sf] exact inv.1 k ik kj . intro k jk kl have jk : j.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi ij)))] exact jk cases Nat.eq_or_lt_of_le jk with \| inl jk => have : swapped[k] = arr[i] := by simp [Fin.eq_of_val_eq jk.symm] apply Vec.get_swap_right rw [this, sf] assumption \| inr jk => have : swapped[k] = arr[k] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk) . apply Fin.ne_of_val_ne exact Nat.ne_of_gt jk rw [this, sf] exact inv.2 k jk kl . intro ij have : j.val - 1 < j.val := by show j.val - 1 + 1 ≤ j.val rw [Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi (by assumption)))] apply Nat.le_refl have ij : i.val ≤ j.val - 1 := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ij cases Nat.eq_or_lt_of_le ij with \| inl ij => have : swapped[j.prev] = arr[j] := by simp [ij.symm, Fin.prev] apply Vec.get_swap_left rw [this, sf] have : i < j := Nat.lt_of_le_of_lt (by assumption : i.val ≤ j.val - 1) (by assumption) exact inv.3 this \| inr ij => have : swapped[j.prev] = arr[j.prev] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt ij . apply Fin.ne_of_val_ne exact Nat.ne_of_lt (by assumption) rw [this, sf] apply inv.1 j.prev ij (by assumption)	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ LoopInvariant (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).snd first first (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).1.val last	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv✝ : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ inv : LoopInvariant swapped first i.prev j.prev last ⊢ LoopInvariant (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).snd first first (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).1.val last
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact ih inv result (by rfl)	case step_ge α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv✝ : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ inv : LoopInvariant swapped first i.prev j.prev last ⊢ LoopInvariant (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).snd first first (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).1.val last	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Vec.get_swap_neq	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ swapped[first] = arr[first]	case ki α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ first ≠ i case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ first ≠ j
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. apply Fin.ne_of_val_ne exact Nat.ne_of_lt fi	case ki α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ first ≠ i case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ first ≠ j	case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ first ≠ j
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. apply Fin.ne_of_val_ne exact Nat.ne_of_lt (Nat.lt_of_lt_of_le fi ij)	case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ first ≠ j	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Fin.ne_of_val_ne	case ki α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ first ≠ i	case ki.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ ¬↑first = ↑i
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact Nat.ne_of_lt fi	case ki.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ ¬↑first = ↑i	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Fin.ne_of_val_ne	case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ first ≠ j	case kj.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ ¬↑first = ↑j
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact Nat.ne_of_lt (Nat.lt_of_lt_of_le fi ij)	case kj.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j ⊢ ¬↑first = ↑j	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	assumption	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] ⊢ first ≤ i.prev	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	assumption	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n eq : partitionImpl arr first i j fi✝ ij = result swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] ⊢ i.prev ≤ j.prev	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply LoopInvariant.intro	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ LoopInvariant swapped first i.prev j.prev last	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ ∀ (k : Fin n), i.prev < k → k < j.prev → swapped[k] < swapped[first] case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first] case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. intro k ik kj have ik : i.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ik cases Nat.eq_or_lt_of_le ik with \| inl ik => have : swapped[k] = arr[j] := by simp [Fin.eq_of_val_eq ik.symm] apply Vec.get_swap_left rw [this, sf] exact inv.3 (Nat.lt_of_lt_of_le (Fin.eq_of_val_eq ik.symm ▸ kj) (Nat.sub_le ..)) \| inr ik => have kj : k < j := (Nat.lt_of_lt_of_le kj (Nat.sub_le ..)) have : swapped[k] = arr[k] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt ik . apply Fin.ne_of_val_ne exact Nat.ne_of_lt kj rw [this, sf] exact inv.1 k ik kj	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ ∀ (k : Fin n), i.prev < k → k < j.prev → swapped[k] < swapped[first] case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first] case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]	case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first] case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. intro k jk kl have jk : j.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi ij)))] exact jk cases Nat.eq_or_lt_of_le jk with \| inl jk => have : swapped[k] = arr[i] := by simp [Fin.eq_of_val_eq jk.symm] apply Vec.get_swap_right rw [this, sf] assumption \| inr jk => have : swapped[k] = arr[k] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk) . apply Fin.ne_of_val_ne exact Nat.ne_of_gt jk rw [this, sf] exact inv.2 k jk kl	case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first] case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. intro ij have : j.val - 1 < j.val := by show j.val - 1 + 1 ≤ j.val rw [Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi (by assumption)))] apply Nat.le_refl have ij : i.val ≤ j.val - 1 := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ij cases Nat.eq_or_lt_of_le ij with \| inl ij => have : swapped[j.prev] = arr[j] := by simp [ij.symm, Fin.prev] apply Vec.get_swap_left rw [this, sf] have : i < j := Nat.lt_of_le_of_lt (by assumption : i.val ≤ j.val - 1) (by assumption) exact inv.3 this \| inr ij => have : swapped[j.prev] = arr[j.prev] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt ij . apply Fin.ne_of_val_ne exact Nat.ne_of_lt (by assumption) rw [this, sf] apply inv.1 j.prev ij (by assumption)	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	intro k ik kj	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ ∀ (k : Fin n), i.prev < k → k < j.prev → swapped[k] < swapped[first]	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik : i.prev < k kj : k < j.prev ⊢ swapped[k] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have ik : i.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)] exact ik	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik : i.prev < k kj : k < j.prev ⊢ swapped[k] < swapped[first]	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝ : i.prev < k kj : k < j.prev ik : ↑i ≤ ↑k ⊢ swapped[k] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	cases Nat.eq_or_lt_of_le ik with \| inl ik => have : swapped[k] = arr[j] := by simp [Fin.eq_of_val_eq ik.symm] apply Vec.get_swap_left rw [this, sf] exact inv.3 (Nat.lt_of_lt_of_le (Fin.eq_of_val_eq ik.symm ▸ kj) (Nat.sub_le ..)) \| inr ik => have kj : k < j := (Nat.lt_of_lt_of_le kj (Nat.sub_le ..)) have : swapped[k] = arr[k] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt ik . apply Fin.ne_of_val_ne exact Nat.ne_of_lt kj rw [this, sf] exact inv.1 k ik kj	case inv₁ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝ : i.prev < k kj : k < j.prev ik : ↑i ≤ ↑k ⊢ swapped[k] < swapped[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik : i.prev < k kj : k < j.prev ⊢ ↑i ≤ ↑k	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik : i.prev < k kj : k < j.prev ⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑k
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact ik	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik : i.prev < k kj : k < j.prev ⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑k	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have : swapped[k] = arr[j] := by simp [Fin.eq_of_val_eq ik.symm] apply Vec.get_swap_left	case inv₁.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k ⊢ swapped[k] < swapped[first]	case inv₁.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k this : swapped[k] = arr[j] ⊢ swapped[k] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	rw [this, sf]	case inv₁.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k this : swapped[k] = arr[j] ⊢ swapped[k] < swapped[first]	case inv₁.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k this : swapped[k] = arr[j] ⊢ arr[j] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact inv.3 (Nat.lt_of_lt_of_le (Fin.eq_of_val_eq ik.symm ▸ kj) (Nat.sub_le ..))	case inv₁.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k this : swapped[k] = arr[j] ⊢ arr[j] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	simp [Fin.eq_of_val_eq ik.symm]	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k ⊢ swapped[k] = arr[j]	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k ⊢ swapped[i] = arr[j]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Vec.get_swap_left	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i = ↑k ⊢ swapped[i] = arr[j]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have kj : k < j := (Nat.lt_of_lt_of_le kj (Nat.sub_le ..))	case inv₁.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k ⊢ swapped[k] < swapped[first]	case inv₁.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ swapped[k] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have : swapped[k] = arr[k] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt ik . apply Fin.ne_of_val_ne exact Nat.ne_of_lt kj	case inv₁.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ swapped[k] < swapped[first]	case inv₁.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j this : swapped[k] = arr[k] ⊢ swapped[k] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	rw [this, sf]	case inv₁.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j this : swapped[k] = arr[k] ⊢ swapped[k] < swapped[first]	case inv₁.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j this : swapped[k] = arr[k] ⊢ arr[k] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact inv.1 k ik kj	case inv₁.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j this : swapped[k] = arr[k] ⊢ arr[k] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Vec.get_swap_neq	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ swapped[k] = arr[k]	case ki α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ k ≠ i case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ k ≠ j
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. apply Fin.ne_of_val_ne exact Nat.ne_of_gt ik	case ki α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ k ≠ i case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ k ≠ j	case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ k ≠ j
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. apply Fin.ne_of_val_ne exact Nat.ne_of_lt kj	case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ k ≠ j	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Fin.ne_of_val_ne	case ki α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ k ≠ i	case ki.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ ¬↑k = ↑i
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact Nat.ne_of_gt ik	case ki.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ ¬↑k = ↑i	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Fin.ne_of_val_ne	case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ k ≠ j	case kj.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ ¬↑k = ↑j
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact Nat.ne_of_lt kj	case kj.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n ik✝¹ : i.prev < k kj✝ : k < j.prev ik✝ : ↑i ≤ ↑k ik : ↑i < ↑k kj : k < j ⊢ ¬↑k = ↑j	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	intro k jk kl	case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first]	case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk : j.prev < k kl : k ≤ last ⊢ ¬swapped[k] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have jk : j.val ≤ k.val := by rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi ij)))] exact jk	case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk : j.prev < k kl : k ≤ last ⊢ ¬swapped[k] < swapped[first]	case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝ : j.prev < k kl : k ≤ last jk : ↑j ≤ ↑k ⊢ ¬swapped[k] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	cases Nat.eq_or_lt_of_le jk with \| inl jk => have : swapped[k] = arr[i] := by simp [Fin.eq_of_val_eq jk.symm] apply Vec.get_swap_right rw [this, sf] assumption \| inr jk => have : swapped[k] = arr[k] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk) . apply Fin.ne_of_val_ne exact Nat.ne_of_gt jk rw [this, sf] exact inv.2 k jk kl	case inv₂ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝ : j.prev < k kl : k ≤ last jk : ↑j ≤ ↑k ⊢ ¬swapped[k] < swapped[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi ij)))]	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk : j.prev < k kl : k ≤ last ⊢ ↑j ≤ ↑k	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk : j.prev < k kl : k ≤ last ⊢ ↑j - Nat.succ 0 + Nat.succ 0 ≤ ↑k
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact jk	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk : j.prev < k kl : k ≤ last ⊢ ↑j - Nat.succ 0 + Nat.succ 0 ≤ ↑k	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have : swapped[k] = arr[i] := by simp [Fin.eq_of_val_eq jk.symm] apply Vec.get_swap_right	case inv₂.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j = ↑k ⊢ ¬swapped[k] < swapped[first]	case inv₂.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j = ↑k this : swapped[k] = arr[i] ⊢ ¬swapped[k] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	rw [this, sf]	case inv₂.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j = ↑k this : swapped[k] = arr[i] ⊢ ¬swapped[k] < swapped[first]	case inv₂.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j = ↑k this : swapped[k] = arr[i] ⊢ ¬arr[i] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	assumption	case inv₂.inl α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j = ↑k this : swapped[k] = arr[i] ⊢ ¬arr[i] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	simp [Fin.eq_of_val_eq jk.symm]	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j = ↑k ⊢ swapped[k] = arr[i]	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j = ↑k ⊢ swapped[j] = arr[i]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Vec.get_swap_right	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j = ↑k ⊢ swapped[j] = arr[i]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have : swapped[k] = arr[k] := by apply Vec.get_swap_neq . apply Fin.ne_of_val_ne exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk) . apply Fin.ne_of_val_ne exact Nat.ne_of_gt jk	case inv₂.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ ¬swapped[k] < swapped[first]	case inv₂.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k this : swapped[k] = arr[k] ⊢ ¬swapped[k] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	rw [this, sf]	case inv₂.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k this : swapped[k] = arr[k] ⊢ ¬swapped[k] < swapped[first]	case inv₂.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k this : swapped[k] = arr[k] ⊢ ¬arr[k] < arr[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact inv.2 k jk kl	case inv₂.inr α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k this : swapped[k] = arr[k] ⊢ ¬arr[k] < arr[first]	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Vec.get_swap_neq	α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ swapped[k] = arr[k]	case ki α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ k ≠ i case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ k ≠ j
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. apply Fin.ne_of_val_ne exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk)	case ki α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ k ≠ i case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ k ≠ j	case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ k ≠ j
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	. apply Fin.ne_of_val_ne exact Nat.ne_of_gt jk	case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ k ≠ j	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Fin.ne_of_val_ne	case ki α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ k ≠ i	case ki.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ ¬↑k = ↑i
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk)	case ki.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ ¬↑k = ↑i	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	apply Fin.ne_of_val_ne	case kj α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ k ≠ j	case kj.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ ¬↑k = ↑j
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	exact Nat.ne_of_gt jk	case kj.h α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ k : Fin n jk✝¹ : j.prev < k kl : k ≤ last jk✝ : ↑j ≤ ↑k jk : ↑j < ↑k ⊢ ¬↑k = ↑j	no goals
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	intro ij	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ij : i.prev < j.prev ⊢ swapped[j.prev] < swapped[first]
https://github.com/pandaman64/QuickSortInLean.git	ab0aaee0aed280959328844f9a6cd13bf00c5935	QuickSortInLean/Sorted.lean	partitionImpl.loop_invariant	[21, 1]	[141, 33]	have : j.val - 1 < j.val := by show j.val - 1 + 1 ≤ j.val rw [Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi (by assumption)))] apply Nat.le_refl	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ij : i.prev < j.prev ⊢ swapped[j.prev] < swapped[first]	case inv₃ α : Type inst✝ : Ord α n : Nat first✝ i✝ j✝ last : Fin n arr : Vec α n first i j : Fin n fi✝ : first ≤ i ij✝ : i ≤ j fi : first < i x✝² : ↑first ≤ ↑i - 1 x✝¹ : ¬arr[i] < arr[first] x✝ : ↑i - 1 ≤ ↑j - 1 ih : LoopInvariant (arr.swap i j) first i.prev j.prev last → ∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n), partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last inv : LoopInvariant arr first i j last swapped : Vec α n := arr.swap i j sf : swapped[first] = arr[first] result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝ ij : i.prev < j.prev this : ↑j - 1 < ↑j ⊢ swapped[j.prev] < swapped[first]

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.