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
| input
stringlengths 73
2.09M
|
|---|---|---|---|---|---|---|---|---|---|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have ij : i.val ≤ j.val - 1 := 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
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]
|
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
ij : ↑i ≤ ↑j - 1
⊢ swapped[j.prev] < swapped[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
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]
TACTIC:
|
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 =>
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✝
ij✝ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij : ↑i ≤ ↑j - 1
⊢ swapped[j.prev] < swapped[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
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
ij : ↑i ≤ ↑j - 1
⊢ swapped[j.prev] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
show j.val - 1 + 1 ≤ j.val
|
α : 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
⊢ ↑j - 1 < ↑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✝
ij : i.prev < j.prev
⊢ ↑j - 1 + 1 ≤ ↑j
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
⊢ ↑j - 1 < ↑j
TACTIC:
|
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.lt_of_lt_of_le fi (by 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
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
⊢ ↑j - 1 + 1 ≤ ↑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✝
ij : i.prev < j.prev
⊢ ↑j ≤ ↑j
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
⊢ ↑j - 1 + 1 ≤ ↑j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
apply Nat.le_refl
|
α : 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
⊢ ↑j ≤ ↑j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
⊢ ↑j ≤ ↑j
TACTIC:
|
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
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
⊢ ↑i ≤ ↑j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
⊢ ↑i ≤ ↑j
TACTIC:
|
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✝
ij : i.prev < j.prev
this : ↑j - 1 < ↑j
⊢ ↑i ≤ ↑j - 1
|
α : 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
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑j - 1
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
⊢ ↑i ≤ ↑j - 1
TACTIC:
|
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
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
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑j - 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑j - 1
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have : swapped[j.prev] = arr[j] := by
simp [ij.symm, Fin.prev]
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
⊢ swapped[j.prev] < 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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this : swapped[j.prev] = arr[j]
⊢ swapped[j.prev] < swapped[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
⊢ swapped[j.prev] < swapped[first]
TACTIC:
|
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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this : swapped[j.prev] = arr[j]
⊢ swapped[j.prev] < 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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this : swapped[j.prev] = arr[j]
⊢ arr[j] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this : swapped[j.prev] = arr[j]
⊢ swapped[j.prev] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have : i < j := Nat.lt_of_le_of_lt (by assumption : i.val ≤ j.val - 1) (by 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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this : swapped[j.prev] = arr[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
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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this✝ : swapped[j.prev] = arr[j]
this : i < j
⊢ arr[j] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this : swapped[j.prev] = arr[j]
⊢ arr[j] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact inv.3 this
|
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✝
ij✝¹ : i.prev < j.prev
this✝¹ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this✝ : swapped[j.prev] = arr[j]
this : i < j
⊢ arr[j] < arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this✝¹ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this✝ : swapped[j.prev] = arr[j]
this : i < j
⊢ arr[j] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
simp [ij.symm, Fin.prev]
|
α : 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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
⊢ swapped[j.prev] = 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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
⊢ swapped[i] = arr[j]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
⊢ swapped[j.prev] = arr[j]
TACTIC:
|
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
⊢ swapped[i] = arr[j]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
⊢ swapped[i] = arr[j]
TACTIC:
|
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
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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this : swapped[j.prev] = arr[j]
⊢ ↑i ≤ ↑j - 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this : swapped[j.prev] = arr[j]
⊢ ↑i ≤ ↑j - 1
TACTIC:
|
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
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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this : swapped[j.prev] = arr[j]
⊢ ↑j - 1 < ↑j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i = ↑j - 1
this : swapped[j.prev] = arr[j]
⊢ ↑j - 1 < ↑j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
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)
|
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ swapped[j.prev] < 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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
this : swapped[j.prev] = arr[j.prev]
⊢ swapped[j.prev] < swapped[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ swapped[j.prev] < swapped[first]
TACTIC:
|
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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
this : swapped[j.prev] = arr[j.prev]
⊢ swapped[j.prev] < 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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
this : swapped[j.prev] = arr[j.prev]
⊢ arr[j.prev] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
this : swapped[j.prev] = arr[j.prev]
⊢ swapped[j.prev] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
apply inv.1 j.prev ij (by assumption)
|
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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
this : swapped[j.prev] = arr[j.prev]
⊢ arr[j.prev] < arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this✝ : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
this : swapped[j.prev] = arr[j.prev]
⊢ arr[j.prev] < arr[first]
TACTIC:
|
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ swapped[j.prev] = arr[j.prev]
|
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ 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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ j
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ swapped[j.prev] = arr[j.prev]
TACTIC:
|
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 ij
|
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ 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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ 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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ j
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ 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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ j
TACTIC:
|
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 (by assumption)
|
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ j
TACTIC:
|
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ 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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ ¬↑j.prev = ↑i
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ i
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact Nat.ne_of_gt ij
|
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ ¬↑j.prev = ↑i
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ ¬↑j.prev = ↑i
TACTIC:
|
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ 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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ ¬↑j.prev = ↑j
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ j.prev ≠ j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact Nat.ne_of_lt (by assumption)
|
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ ¬↑j.prev = ↑j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
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✝
ij✝¹ : i.prev < j.prev
this : ↑j - 1 < ↑j
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ ¬↑j.prev = ↑j
TACTIC:
|
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
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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ ↑j.prev < ↑j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
⊢ ↑j.prev < ↑j
TACTIC:
|
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
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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
this : swapped[j.prev] = arr[j.prev]
⊢ j.prev < j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
ij✝ : ↑i ≤ ↑j - 1
ij : ↑i < ↑j - 1
this : swapped[j.prev] = arr[j.prev]
⊢ j.prev < j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
rfl
|
α : 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
⊢ partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : 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
⊢ partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
induction arr, first, i, j, fi, ij using partitionImpl.induct' with
| base => simp [*]
| step_lt => simp [*]
| step_ge arr first i j _ ij fi =>
simp [*]
have fj : first < j := Nat.lt_of_lt_of_le fi ij
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 fj
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij : i ≤ j
⊢ (partitionImpl arr first i j fi ij).snd[first] = arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij : i ≤ j
⊢ (partitionImpl arr first i j fi ij).snd[first] = arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
simp [*]
|
case base
α : Type
inst✝ : Ord α
n : Nat
first i j : Fin n
arr✝ : Vec α n
first✝ i✝ j✝ : Fin n
fi✝ : first✝ ≤ i✝
ij✝ : i✝ ≤ j✝
x✝ : ¬first✝ < i✝
⊢ (partitionImpl arr✝ first✝ i✝ j✝ fi✝ ij✝).snd[first✝] = arr✝[first✝]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case base
α : Type
inst✝ : Ord α
n : Nat
first i j : Fin n
arr✝ : Vec α n
first✝ i✝ j✝ : Fin n
fi✝ : first✝ ≤ i✝
ij✝ : i✝ ≤ j✝
x✝ : ¬first✝ < i✝
⊢ (partitionImpl arr✝ first✝ i✝ j✝ fi✝ ij✝).snd[first✝] = arr✝[first✝]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
simp [*]
|
case step_lt
α : Type
inst✝ : Ord α
n : Nat
first i j : Fin n
arr✝ : Vec α n
first✝ i✝ j✝ : Fin n
fi✝ : first✝ ≤ i✝
ij✝ : i✝ ≤ j✝
x✝³ : first✝ < i✝
x✝² : ↑first✝ ≤ ↑i✝ - 1
x✝¹ : arr✝[i✝] < arr✝[first✝]
x✝ : ↑i✝ - 1 ≤ ↑j✝
ih✝ : (partitionImpl arr✝ first✝ i✝.prev j✝ x✝² x✝).snd[first✝] = arr✝[first✝]
⊢ (partitionImpl arr✝ first✝ i✝ j✝ fi✝ ij✝).snd[first✝] = arr✝[first✝]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_lt
α : Type
inst✝ : Ord α
n : Nat
first i j : Fin n
arr✝ : Vec α n
first✝ i✝ j✝ : Fin n
fi✝ : first✝ ≤ i✝
ij✝ : i✝ ≤ j✝
x✝³ : first✝ < i✝
x✝² : ↑first✝ ≤ ↑i✝ - 1
x✝¹ : arr✝[i✝] < arr✝[first✝]
x✝ : ↑i✝ - 1 ≤ ↑j✝
ih✝ : (partitionImpl arr✝ first✝ i✝.prev j✝ x✝² x✝).snd[first✝] = arr✝[first✝]
⊢ (partitionImpl arr✝ first✝ i✝ j✝ fi✝ ij✝).snd[first✝] = arr✝[first✝]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
simp [*]
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
⊢ (partitionImpl arr first i j fi✝ ij).snd[first] = arr[first]
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
⊢ (arr.swap i j)[first] = arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
⊢ (partitionImpl arr first i j fi✝ ij).snd[first] = arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
have fj : first < j := Nat.lt_of_lt_of_le fi ij
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
⊢ (arr.swap i j)[first] = arr[first]
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ (arr.swap i j)[first] = arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
⊢ (arr.swap i j)[first] = arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
apply Vec.get_swap_neq
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ (arr.swap i j)[first] = arr[first]
|
case step_ge.ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ i
case step_ge.kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ j
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ (arr.swap i j)[first] = arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt fi
|
case step_ge.ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ i
case step_ge.kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ j
|
case step_ge.kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ j
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge.ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ i
case step_ge.kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt fj
|
case step_ge.kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge.kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
apply Fin.ne_of_val_ne
|
case step_ge.ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ i
|
case step_ge.ki.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ ¬↑first = ↑i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge.ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ i
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
exact Nat.ne_of_lt fi
|
case step_ge.ki.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ ¬↑first = ↑i
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge.ki.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ ¬↑first = ↑i
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
apply Fin.ne_of_val_ne
|
case step_ge.kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ j
|
case step_ge.kj.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ ¬↑first = ↑j
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge.kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ first ≠ j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.first_eq
|
[143, 1]
|
[157, 28]
|
exact Nat.ne_of_lt fj
|
case step_ge.kj.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ ¬↑first = ↑j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge.kj.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ : 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✝ : (partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝).snd[first] = (arr.swap i j)[first]
fj : first < j
⊢ ¬↑first = ↑j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
let afterLoop := partitionImpl arr first last last fl (Nat.le_refl _)
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
let mid := afterLoop.1
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
let arr' := afterLoop.2
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have : mid < n := Nat.lt_of_le_of_lt mid.property.2 last.isLt
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
let swapped := arr'.swap first ⟨mid, by assumption⟩
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have : result.1 = mid := by
rw [←eq]
unfold partition
simp [afterLoop]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have : result.2 = swapped := by
rw [←eq]
unfold partition
simp [afterLoop, dbgTraceIfShared]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have first_eq : arr'[first] = arr[first] := by
apply partitionImpl.first_eq
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
let inv₀ : partitionImpl.LoopInvariant arr first last last last := by
apply partitionImpl.LoopInvariant.intro
. intro k lk kl
exact (Nat.lt_irrefl k (Nat.lt_trans kl lk)).elim
. intro k lk kl
exact (Nat.lt_irrefl k (Nat.lt_of_le_of_lt kl lk)).elim
. intro ll
exact (Nat.lt_irrefl last ll).elim
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
let inv := partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl _) inv₀ afterLoop (by rfl)
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have p₁ (k : Fin n) (fk : first ≤ k) (km : k.val < mid) : swapped[k] <o arr[first] := by
cases Nat.eq_or_lt_of_le fk with
| inl fk =>
have : swapped[k] = swapped[first] := by
simp [Fin.eq_of_val_eq fk]
rw [this]
have : swapped[first] = arr'[mid.val] := by
apply Vec.get_swap_left
rw [this, ←first_eq]
exact inv.3 (Fin.eq_of_val_eq fk ▸ km)
| inr fk =>
have : swapped[k] = arr'[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt fk
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt km
rw [this, ←first_eq]
exact inv.1 k fk km
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have p₂ : swapped[mid.val] = arr[first] := by
have : swapped[mid.val] = arr'[first] := by
apply Vec.get_swap_right
rw [this]
assumption
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have p₃ (k : Fin n) (mk : mid < k.val) (kl : k ≤ last) : ¬swapped[k] <o arr[first] := by
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 mid.property.1 mk)
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt mk
rw [this, ←first_eq]
exact inv.2 k mk kl
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
apply And.intro
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
case left
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ ∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]
case right
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ result.snd[result.fst.val] = arr[first] ∧ ∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ (∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]) ∧
result.snd[result.fst.val] = arr[first] ∧
∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
. simp [*]
apply p₁
|
case left
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ ∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]
case right
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ result.snd[result.fst.val] = arr[first] ∧ ∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
case right
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ result.snd[result.fst.val] = arr[first] ∧ ∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case left
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ ∀ (k : Fin n), first ≤ k → ↑k < ↑result.fst.val → result.snd[k] < arr[first]
case right
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ result.snd[result.fst.val] = arr[first] ∧ ∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
. apply And.intro
. simp [*]
. simp [*]
apply p₃
|
case right
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ result.snd[result.fst.val] = arr[first] ∧ ∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case right
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
p₃ : ∀ (k : Fin n), ↑mid.val < ↑k → k ≤ last → ¬swapped[k] < arr[first]
⊢ result.snd[result.fst.val] = arr[first] ∧ ∀ (k : Fin n), ↑result.fst.val < ↑k → k ≤ last → ¬result.snd[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
assumption
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
⊢ ↑mid.val < n
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
⊢ ↑mid.val < n
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
rw [←eq]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ result.fst = mid
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ (_root_.partition arr first last fl).fst = mid
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ result.fst = mid
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
unfold partition
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ (_root_.partition arr first last fl).fst = mid
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ (let result := partitionImpl arr first last last fl ⋯;
let mid := result.fst;
let arr_1 := result.snd;
(mid, (dbgTraceIfShared "swap2" arr_1).swap first ⟨↑mid.val, ⋯⟩)).fst =
mid
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ (_root_.partition arr first last fl).fst = mid
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
simp [afterLoop]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ (let result := partitionImpl arr first last last fl ⋯;
let mid := result.fst;
let arr_1 := result.snd;
(mid, (dbgTraceIfShared "swap2" arr_1).swap first ⟨↑mid.val, ⋯⟩)).fst =
mid
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this⟩
⊢ (let result := partitionImpl arr first last last fl ⋯;
let mid := result.fst;
let arr_1 := result.snd;
(mid, (dbgTraceIfShared "swap2" arr_1).swap first ⟨↑mid.val, ⋯⟩)).fst =
mid
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
rw [←eq]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ result.snd = swapped
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ (_root_.partition arr first last fl).snd = swapped
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ result.snd = swapped
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
unfold partition
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ (_root_.partition arr first last fl).snd = swapped
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ (let result := partitionImpl arr first last last fl ⋯;
let mid := result.fst;
let arr_1 := result.snd;
(mid, (dbgTraceIfShared "swap2" arr_1).swap first ⟨↑mid.val, ⋯⟩)).snd =
swapped
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ (_root_.partition arr first last fl).snd = swapped
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
simp [afterLoop, dbgTraceIfShared]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ (let result := partitionImpl arr first last last fl ⋯;
let mid := result.fst;
let arr_1 := result.snd;
(mid, (dbgTraceIfShared "swap2" arr_1).swap first ⟨↑mid.val, ⋯⟩)).snd =
swapped
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝⟩
this : result.fst = mid
⊢ (let result := partitionImpl arr first last last fl ⋯;
let mid := result.fst;
let arr_1 := result.snd;
(mid, (dbgTraceIfShared "swap2" arr_1).swap first ⟨↑mid.val, ⋯⟩)).snd =
swapped
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
apply partitionImpl.first_eq
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
⊢ arr'[first] = arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
⊢ arr'[first] = arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
apply partitionImpl.LoopInvariant.intro
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ partitionImpl.LoopInvariant arr first last last last
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k < last → arr[k] < arr[first]
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ partitionImpl.LoopInvariant arr first last last last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
. intro k lk kl
exact (Nat.lt_irrefl k (Nat.lt_trans kl lk)).elim
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k < last → arr[k] < arr[first]
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inv₁
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k < last → arr[k] < arr[first]
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
. intro k lk kl
exact (Nat.lt_irrefl k (Nat.lt_of_le_of_lt kl lk)).elim
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
. intro ll
exact (Nat.lt_irrefl last ll).elim
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
intro k lk kl
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k < last → arr[k] < arr[first]
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
k : Fin n
lk : last < k
kl : k < last
⊢ arr[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inv₁
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k < last → arr[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
exact (Nat.lt_irrefl k (Nat.lt_trans kl lk)).elim
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
k : Fin n
lk : last < k
kl : k < last
⊢ arr[k] < arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inv₁
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
k : Fin n
lk : last < k
kl : k < last
⊢ arr[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
intro k lk kl
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k ≤ last → ¬arr[k] < arr[first]
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
k : Fin n
lk : last < k
kl : k ≤ last
⊢ ¬arr[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ ∀ (k : Fin n), last < k → k ≤ last → ¬arr[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
exact (Nat.lt_irrefl k (Nat.lt_of_le_of_lt kl lk)).elim
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
k : Fin n
lk : last < k
kl : k ≤ last
⊢ ¬arr[k] < arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inv₂
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
k : Fin n
lk : last < k
kl : k ≤ last
⊢ ¬arr[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
intro ll
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
ll : last < last
⊢ arr[last] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
⊢ last < last → arr[last] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
exact (Nat.lt_irrefl last ll).elim
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
ll : last < last
⊢ arr[last] < arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inv₃
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
ll : last < last
⊢ arr[last] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
rfl
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
⊢ partitionImpl arr first last last fl ⋯ = afterLoop
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
⊢ partitionImpl arr first last last fl ⋯ = afterLoop
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
cases Nat.eq_or_lt_of_le fk with
| inl fk =>
have : swapped[k] = swapped[first] := by
simp [Fin.eq_of_val_eq fk]
rw [this]
have : swapped[first] = arr'[mid.val] := by
apply Vec.get_swap_left
rw [this, ←first_eq]
exact inv.3 (Fin.eq_of_val_eq fk ▸ km)
| inr fk =>
have : swapped[k] = arr'[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt fk
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt km
rw [this, ←first_eq]
exact inv.1 k fk km
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk : first ≤ k
km : ↑k < ↑mid.val
⊢ swapped[k] < arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk : first ≤ k
km : ↑k < ↑mid.val
⊢ swapped[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have : swapped[k] = swapped[first] := by
simp [Fin.eq_of_val_eq fk]
|
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
⊢ swapped[k] < arr[first]
|
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this : swapped[k] = swapped[first]
⊢ swapped[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
⊢ swapped[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
rw [this]
|
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this : swapped[k] = swapped[first]
⊢ swapped[k] < arr[first]
|
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this : swapped[k] = swapped[first]
⊢ swapped[first] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this : swapped[k] = swapped[first]
⊢ swapped[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have : swapped[first] = arr'[mid.val] := by
apply Vec.get_swap_left
|
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this : swapped[k] = swapped[first]
⊢ swapped[first] < arr[first]
|
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝³ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝³⟩
this✝² : result.fst = mid
this✝¹ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this✝ : swapped[k] = swapped[first]
this : swapped[first] = arr'[mid.val]
⊢ swapped[first] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this : swapped[k] = swapped[first]
⊢ swapped[first] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
rw [this, ←first_eq]
|
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝³ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝³⟩
this✝² : result.fst = mid
this✝¹ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this✝ : swapped[k] = swapped[first]
this : swapped[first] = arr'[mid.val]
⊢ swapped[first] < arr[first]
|
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝³ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝³⟩
this✝² : result.fst = mid
this✝¹ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this✝ : swapped[k] = swapped[first]
this : swapped[first] = arr'[mid.val]
⊢ arr'[mid.val] < arr'[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝³ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝³⟩
this✝² : result.fst = mid
this✝¹ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this✝ : swapped[k] = swapped[first]
this : swapped[first] = arr'[mid.val]
⊢ swapped[first] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
exact inv.3 (Fin.eq_of_val_eq fk ▸ km)
|
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝³ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝³⟩
this✝² : result.fst = mid
this✝¹ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this✝ : swapped[k] = swapped[first]
this : swapped[first] = arr'[mid.val]
⊢ arr'[mid.val] < arr'[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inl
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝³ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝³⟩
this✝² : result.fst = mid
this✝¹ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this✝ : swapped[k] = swapped[first]
this : swapped[first] = arr'[mid.val]
⊢ arr'[mid.val] < arr'[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
simp [Fin.eq_of_val_eq fk]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
⊢ swapped[k] = swapped[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
⊢ swapped[k] = swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
apply Vec.get_swap_left
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this : swapped[k] = swapped[first]
⊢ swapped[first] = arr'[mid.val]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first = ↑k
this : swapped[k] = swapped[first]
⊢ swapped[first] = arr'[mid.val]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have : swapped[k] = arr'[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt fk
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt km
|
case inr
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ swapped[k] < arr[first]
|
case inr
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
this : swapped[k] = arr'[k]
⊢ swapped[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ swapped[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
rw [this, ←first_eq]
|
case inr
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
this : swapped[k] = arr'[k]
⊢ swapped[k] < arr[first]
|
case inr
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
this : swapped[k] = arr'[k]
⊢ arr'[k] < arr'[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
this : swapped[k] = arr'[k]
⊢ swapped[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
exact inv.1 k fk km
|
case inr
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
this : swapped[k] = arr'[k]
⊢ arr'[k] < arr'[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case inr
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
this : swapped[k] = arr'[k]
⊢ arr'[k] < arr'[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
apply Vec.get_swap_neq
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ swapped[k] = arr'[k]
|
case ki
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ first
case kj
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ ⟨↑mid.val, this✝¹⟩
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ swapped[k] = arr'[k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt fk
|
case ki
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ first
case kj
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ ⟨↑mid.val, this✝¹⟩
|
case kj
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ ⟨↑mid.val, this✝¹⟩
|
Please generate a tactic in lean4 to solve the state.
STATE:
case ki
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ first
case kj
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ ⟨↑mid.val, this✝¹⟩
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt km
|
case kj
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ ⟨↑mid.val, this✝¹⟩
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case kj
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ ⟨↑mid.val, this✝¹⟩
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
apply Fin.ne_of_val_ne
|
case ki
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ first
|
case ki.h
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ ¬↑k = ↑first
|
Please generate a tactic in lean4 to solve the state.
STATE:
case ki
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ first
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
exact Nat.ne_of_gt fk
|
case ki.h
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ ¬↑k = ↑first
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case ki.h
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ ¬↑k = ↑first
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
apply Fin.ne_of_val_ne
|
case kj
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ ⟨↑mid.val, this✝¹⟩
|
case kj.h
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ ¬↑k = ↑⟨↑mid.val, this✝¹⟩
|
Please generate a tactic in lean4 to solve the state.
STATE:
case kj
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ k ≠ ⟨↑mid.val, this✝¹⟩
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
exact Nat.ne_of_lt km
|
case kj.h
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ ¬↑k = ↑⟨↑mid.val, this✝¹⟩
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case kj.h
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
k : Fin n
fk✝ : first ≤ k
km : ↑k < ↑mid.val
fk : ↑first < ↑k
⊢ ¬↑k = ↑⟨↑mid.val, this✝¹⟩
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
have : swapped[mid.val] = arr'[first] := by
apply Vec.get_swap_right
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
⊢ swapped[mid.val] = arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
this : swapped[mid.val] = arr'[first]
⊢ swapped[mid.val] = arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
⊢ swapped[mid.val] = arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
rw [this]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
this : swapped[mid.val] = arr'[first]
⊢ swapped[mid.val] = arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
this : swapped[mid.val] = arr'[first]
⊢ arr'[first] = arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
this : swapped[mid.val] = arr'[first]
⊢ swapped[mid.val] = arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
assumption
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
this : swapped[mid.val] = arr'[first]
⊢ arr'[first] = arr[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
this : swapped[mid.val] = arr'[first]
⊢ arr'[first] = arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
apply Vec.get_swap_right
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
⊢ swapped[mid.val] = arr'[first]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
⊢ swapped[mid.val] = arr'[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
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 mid.property.1 mk)
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt mk
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
k : Fin n
mk : ↑mid.val < ↑k
kl : k ≤ last
⊢ ¬swapped[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
k : Fin n
mk : ↑mid.val < ↑k
kl : k ≤ last
this : swapped[k] = arr'[k]
⊢ ¬swapped[k] < arr[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝¹ : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝¹⟩
this✝ : result.fst = mid
this : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
k : Fin n
mk : ↑mid.val < ↑k
kl : k ≤ last
⊢ ¬swapped[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partition.partition
|
[159, 1]
|
[238, 15]
|
rw [this, ←first_eq]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
k : Fin n
mk : ↑mid.val < ↑k
kl : k ≤ last
this : swapped[k] = arr'[k]
⊢ ¬swapped[k] < arr[first]
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
k : Fin n
mk : ↑mid.val < ↑k
kl : k ≤ last
this : swapped[k] = arr'[k]
⊢ ¬arr'[k] < arr'[first]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first last : Fin n
fl : first ≤ last
result : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n
eq : _root_.partition arr first last fl = result
afterLoop : { mid // first ≤ mid ∧ mid ≤ last } × Vec α n := partitionImpl arr first last last fl ⋯
mid : { mid // first ≤ mid ∧ mid ≤ last } := afterLoop.fst
arr' : Vec α n := afterLoop.snd
this✝² : ↑mid.val < n
swapped : Vec α n := arr'.swap first ⟨↑mid.val, this✝²⟩
this✝¹ : result.fst = mid
this✝ : result.snd = swapped
first_eq : arr'[first] = arr[first]
inv₀ : partitionImpl.LoopInvariant arr first last last last :=
{ inv₁ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_trans kl lk)),
inv₂ := fun k lk kl => False.elim (Nat.lt_irrefl (↑k) (Nat.lt_of_le_of_lt kl lk)),
inv₃ := fun ll => False.elim (Nat.lt_irrefl (↑last) ll) }
inv : partitionImpl.LoopInvariant afterLoop.snd first first ⟨↑afterLoop.fst.val, ⋯⟩ last :=
partitionImpl.loop_invariant arr first last last last fl (Nat.le_refl ↑last) inv₀ afterLoop
(Eq.refl (partitionImpl arr first last last fl (Nat.le_refl ↑last)))
p₁ : ∀ (k : Fin n), first ≤ k → ↑k < ↑mid.val → swapped[k] < arr[first]
p₂ : swapped[mid.val] = arr[first]
k : Fin n
mk : ↑mid.val < ↑k
kl : k ≤ last
this : swapped[k] = arr'[k]
⊢ ¬swapped[k] < arr[first]
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.