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/Order.lean
|
Order.not_lt_of_le
|
[53, 1]
|
[61, 18]
|
simp [leOfOrd, cmp] at h
|
α : Type
inst✝ : Order α
x y : α
h : x ≤ y
cmp : compare x y = Ordering.gt
⊢ ¬y < x
|
α : Type
inst✝ : Order α
x y : α
cmp : compare x y = Ordering.gt
h : Ordering.gt.isLE = true
⊢ ¬y < x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Order α
x y : α
h : x ≤ y
cmp : compare x y = Ordering.gt
⊢ ¬y < x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Order.lean
|
Order.not_lt_of_le
|
[53, 1]
|
[61, 18]
|
contradiction
|
α : Type
inst✝ : Order α
x y : α
cmp : compare x y = Ordering.gt
h : Ordering.gt.isLE = true
⊢ ¬y < x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Order α
x y : α
cmp : compare x y = Ordering.gt
h : Ordering.gt.isLE = true
⊢ ¬y < x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Order.lean
|
Order.le_of_lt
|
[63, 1]
|
[70, 18]
|
show (compare x y).isLE
|
α : Type
inst✝ : Order α
x y : α
h : x < y
⊢ x ≤ y
|
α : Type
inst✝ : Order α
x y : α
h : x < y
⊢ (compare x y).isLE = true
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Order α
x y : α
h : x < y
⊢ x ≤ y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Order.lean
|
Order.le_of_lt
|
[63, 1]
|
[70, 18]
|
simp [ltOfOrd] at h
|
α : Type
inst✝ : Order α
x y : α
h : x < y
⊢ (compare x y).isLE = true
|
α : Type
inst✝ : Order α
x y : α
h : compare x y = Ordering.lt
⊢ (compare x y).isLE = true
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Order α
x y : α
h : x < y
⊢ (compare x y).isLE = true
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Order.lean
|
Order.le_of_lt
|
[63, 1]
|
[70, 18]
|
match cmp : compare x y with
| .lt => decide
| .eq | .gt =>
rw [cmp] at h
contradiction
|
α : Type
inst✝ : Order α
x y : α
h : compare x y = Ordering.lt
⊢ (compare x y).isLE = true
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Order α
x y : α
h : compare x y = Ordering.lt
⊢ (compare x y).isLE = true
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Order.lean
|
Order.le_of_lt
|
[63, 1]
|
[70, 18]
|
decide
|
α : Type
inst✝ : Order α
x y : α
h cmp : compare x y = Ordering.lt
⊢ Ordering.lt.isLE = true
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Order α
x y : α
h cmp : compare x y = Ordering.lt
⊢ Ordering.lt.isLE = true
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Order.lean
|
Order.le_of_lt
|
[63, 1]
|
[70, 18]
|
rw [cmp] at h
|
α : Type
inst✝ : Order α
x y : α
h : compare x y = Ordering.lt
cmp : compare x y = Ordering.gt
⊢ Ordering.gt.isLE = true
|
α : Type
inst✝ : Order α
x y : α
h : Ordering.gt = Ordering.lt
cmp : compare x y = Ordering.gt
⊢ Ordering.gt.isLE = true
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Order α
x y : α
h : compare x y = Ordering.lt
cmp : compare x y = Ordering.gt
⊢ Ordering.gt.isLE = true
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Order.lean
|
Order.le_of_lt
|
[63, 1]
|
[70, 18]
|
contradiction
|
α : Type
inst✝ : Order α
x y : α
h : Ordering.gt = Ordering.lt
cmp : compare x y = Ordering.gt
⊢ Ordering.gt.isLE = true
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Order α
x y : α
h : Ordering.gt = Ordering.lt
cmp : compare x y = Ordering.gt
⊢ Ordering.gt.isLE = true
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
induction arr, first, i, j, fi, ij using partitionImpl.induct' with
| base arr first i j fi _ h =>
revert result
simp [*]
have : i = first := Fin.eq_of_val_eq (Nat.le_antisymm (Nat.le_of_not_lt h) fi)
exact this ▸ inv
| step_lt arr first i j _ _ fi _ lt _ ih =>
have inv : LoopInvariant arr first i.prev j last := by
apply LoopInvariant.intro
. intro k ik kj
have ik : i.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ik
cases Nat.eq_or_lt_of_le ik with
| inl ik =>
simp [Fin.eq_of_val_eq ik] at lt
exact lt
| inr ik => exact inv.1 k ik kj
. exact inv.2
. intro ij
have ij : i.val ≤ j.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ij
cases Nat.eq_or_lt_of_le ij with
| inl ij =>
simp [Fin.eq_of_val_eq ij.symm]
assumption
| inr ij => exact inv.3 ij
simp [*] at eq
apply ih inv result eq
| step_ge arr first i j _ ij fi _ _ _ ih =>
let swapped := arr.swap i j
have sf : swapped[first] = arr[first] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt fi
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt (Nat.lt_of_lt_of_le fi ij)
let result := partitionImpl swapped first i.prev j.prev (by assumption) (by assumption)
subst eq
simp [*]
have inv : LoopInvariant swapped first i.prev j.prev last := by
apply LoopInvariant.intro
. intro k ik kj
have ik : i.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ik
cases Nat.eq_or_lt_of_le ik with
| inl ik =>
have : swapped[k] = arr[j] := by
simp [Fin.eq_of_val_eq ik.symm]
apply Vec.get_swap_left
rw [this, sf]
exact inv.3 (Nat.lt_of_lt_of_le (Fin.eq_of_val_eq ik.symm ▸ kj) (Nat.sub_le ..))
| inr ik =>
have kj : k < j := (Nat.lt_of_lt_of_le kj (Nat.sub_le ..))
have : swapped[k] = arr[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt ik
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt kj
rw [this, sf]
exact inv.1 k ik kj
. intro k jk kl
have jk : j.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi ij)))]
exact jk
cases Nat.eq_or_lt_of_le jk with
| inl jk =>
have : swapped[k] = arr[i] := by
simp [Fin.eq_of_val_eq jk.symm]
apply Vec.get_swap_right
rw [this, sf]
assumption
| inr jk =>
have : swapped[k] = arr[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk)
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt jk
rw [this, sf]
exact inv.2 k jk kl
. intro ij
have : j.val - 1 < j.val := by
show j.val - 1 + 1 ≤ j.val
rw [Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi (by assumption)))]
apply Nat.le_refl
have ij : i.val ≤ j.val - 1 := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ij
cases Nat.eq_or_lt_of_le ij with
| inl ij =>
have : swapped[j.prev] = arr[j] := by
simp [ij.symm, Fin.prev]
apply Vec.get_swap_left
rw [this, sf]
have : i < j := Nat.lt_of_le_of_lt (by assumption : i.val ≤ j.val - 1) (by assumption)
exact inv.3 this
| inr ij =>
have : swapped[j.prev] = arr[j.prev] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt ij
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt (by assumption)
rw [this, sf]
apply inv.1 j.prev ij (by assumption)
exact ih inv result (by rfl)
|
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first i j last : Fin n
fi : first ≤ i
ij : i ≤ j
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi ij = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Ord α
n : Nat
arr : Vec α n
first i j last : Fin n
fi : first ≤ i
ij : i ≤ j
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi ij = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
revert result
|
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi ij✝ = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
⊢ ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i j fi ij✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi ij✝ = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
simp [*]
|
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
⊢ ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i j fi ij✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
⊢ LoopInvariant arr first first j last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
⊢ ∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i j fi ij✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have : i = first := Fin.eq_of_val_eq (Nat.le_antisymm (Nat.le_of_not_lt h) fi)
|
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
⊢ LoopInvariant arr first first j last
|
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
this : i = first
⊢ LoopInvariant arr first first j last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
⊢ LoopInvariant arr first first j last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact this ▸ inv
|
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
this : i = first
⊢ LoopInvariant arr first first j last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case base
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi : first ≤ i
ij✝ : i ≤ j
h : ¬first < i
inv : LoopInvariant arr first i j last
this : i = first
⊢ LoopInvariant arr first first j last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have inv : LoopInvariant arr first i.prev j last := by
apply LoopInvariant.intro
. intro k ik kj
have ik : i.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ik
cases Nat.eq_or_lt_of_le ik with
| inl ik =>
simp [Fin.eq_of_val_eq ik] at lt
exact lt
| inr ik => exact inv.1 k ik kj
. exact inv.2
. intro ij
have ij : i.val ≤ j.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ij
cases Nat.eq_or_lt_of_le ij with
| inl ij =>
simp [Fin.eq_of_val_eq ij.symm]
assumption
| inr ij => exact inv.3 ij
|
case step_lt
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
case step_lt
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv✝ : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
inv : LoopInvariant arr first i.prev j last
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_lt
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
simp [*] at eq
|
case step_lt
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv✝ : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
inv : LoopInvariant arr first i.prev j last
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
case step_lt
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv✝ : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
inv : LoopInvariant arr first i.prev j last
eq : partitionImpl arr first i.prev j ⋯ ⋯ = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_lt
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv✝ : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
inv : LoopInvariant arr first i.prev j last
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
apply ih inv result eq
|
case step_lt
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv✝ : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
inv : LoopInvariant arr first i.prev j last
eq : partitionImpl arr first i.prev j ⋯ ⋯ = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_lt
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv✝ : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
inv : LoopInvariant arr first i.prev j last
eq : partitionImpl arr first i.prev j ⋯ ⋯ = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
apply LoopInvariant.intro
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ LoopInvariant arr first i.prev j last
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), i.prev < k → k < j → arr[k] < arr[first]
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ LoopInvariant arr first i.prev j last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
. intro k ik kj
have ik : i.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ik
cases Nat.eq_or_lt_of_le ik with
| inl ik =>
simp [Fin.eq_of_val_eq ik] at lt
exact lt
| inr ik => exact inv.1 k ik kj
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), i.prev < k → k < j → arr[k] < arr[first]
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), i.prev < k → k < j → arr[k] < arr[first]
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
. exact inv.2
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
. intro ij
have ij : i.val ≤ j.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ij
cases Nat.eq_or_lt_of_le ij with
| inl ij =>
simp [Fin.eq_of_val_eq ij.symm]
assumption
| inr ij => exact inv.3 ij
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
|
no goals
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
intro k ik kj
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), i.prev < k → k < j → arr[k] < arr[first]
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik : i.prev < k
kj : k < j
⊢ arr[k] < arr[first]
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), i.prev < k → k < j → arr[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have ik : i.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ik
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik : i.prev < k
kj : k < j
⊢ arr[k] < arr[first]
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik✝ : i.prev < k
kj : k < j
ik : ↑i ≤ ↑k
⊢ arr[k] < arr[first]
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik : i.prev < k
kj : k < j
⊢ arr[k] < arr[first]
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 ik with
| inl ik =>
simp [Fin.eq_of_val_eq ik] at lt
exact lt
| inr ik => exact inv.1 k ik kj
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik✝ : i.prev < k
kj : k < j
ik : ↑i ≤ ↑k
⊢ arr[k] < arr[first]
|
no goals
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik✝ : i.prev < k
kj : k < j
ik : ↑i ≤ ↑k
⊢ arr[k] < arr[first]
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik : i.prev < k
kj : k < j
⊢ ↑i ≤ ↑k
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik : i.prev < k
kj : k < j
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑k
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik : i.prev < k
kj : k < j
⊢ ↑i ≤ ↑k
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact ik
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik : i.prev < k
kj : k < j
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑k
|
no goals
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik : i.prev < k
kj : k < j
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑k
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
simp [Fin.eq_of_val_eq ik] at lt
|
case inv₁.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik✝¹ : i.prev < k
kj : k < j
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
⊢ arr[k] < arr[first]
|
case inv₁.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik✝¹ : i.prev < k
kj : k < j
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
lt : arr[k] < arr[first]
⊢ arr[k] < arr[first]
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik✝¹ : i.prev < k
kj : k < j
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
⊢ arr[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact lt
|
case inv₁.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik✝¹ : i.prev < k
kj : k < j
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
lt : arr[k] < arr[first]
⊢ arr[k] < arr[first]
|
no goals
|
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✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik✝¹ : i.prev < k
kj : k < j
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
lt : arr[k] < arr[first]
⊢ arr[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact inv.1 k ik kj
|
case inv₁.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik✝¹ : i.prev < k
kj : k < j
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
⊢ arr[k] < arr[first]
|
no goals
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
k : Fin n
ik✝¹ : i.prev < k
kj : k < j
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
⊢ arr[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact inv.2
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first]
|
no goals
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ ∀ (k : Fin n), j < k → k ≤ last → ¬arr[k] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
intro ij
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
ij : i.prev < j
⊢ arr[j] < arr[first]
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
⊢ i.prev < j → arr[j] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have ij : i.val ≤ j.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ij
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
ij : i.prev < j
⊢ arr[j] < arr[first]
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝¹ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝¹ = result
ij✝ : i.prev < j
ij : ↑i ≤ ↑j
⊢ arr[j] < arr[first]
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
ij : i.prev < j
⊢ arr[j] < arr[first]
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 =>
simp [Fin.eq_of_val_eq ij.symm]
assumption
| inr ij => exact inv.3 ij
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝¹ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝¹ = result
ij✝ : i.prev < j
ij : ↑i ≤ ↑j
⊢ arr[j] < arr[first]
|
no goals
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝¹ = result
ij✝ : i.prev < j
ij : ↑i ≤ ↑j
⊢ arr[j] < arr[first]
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
ij : i.prev < j
⊢ ↑i ≤ ↑j
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
ij : i.prev < j
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑j
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
ij : i.prev < j
⊢ ↑i ≤ ↑j
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
ij : i.prev < j
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑j
|
no goals
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝ = result
ij : i.prev < j
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
simp [Fin.eq_of_val_eq ij.symm]
|
case inv₃.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝² : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝² = result
ij✝¹ : i.prev < j
ij✝ : ↑i ≤ ↑j
ij : ↑i = ↑j
⊢ arr[j] < arr[first]
|
case inv₃.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝² : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝² = result
ij✝¹ : i.prev < j
ij✝ : ↑i ≤ ↑j
ij : ↑i = ↑j
⊢ arr[i] < arr[first]
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝² = result
ij✝¹ : i.prev < j
ij✝ : ↑i ≤ ↑j
ij : ↑i = ↑j
⊢ arr[j] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
assumption
|
case inv₃.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝² : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝² = result
ij✝¹ : i.prev < j
ij✝ : ↑i ≤ ↑j
ij : ↑i = ↑j
⊢ arr[i] < arr[first]
|
no goals
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝² = result
ij✝¹ : i.prev < j
ij✝ : ↑i ≤ ↑j
ij : ↑i = ↑j
⊢ arr[i] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact inv.3 ij
|
case inv₃.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝² : i ≤ j
fi : first < i
x✝¹ : ↑first ≤ ↑i - 1
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝² = result
ij✝¹ : i.prev < j
ij✝ : ↑i ≤ ↑j
ij : ↑i < ↑j
⊢ arr[j] < arr[first]
|
no goals
|
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
lt : arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j
ih :
LoopInvariant arr first i.prev j last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n),
partitionImpl arr first i.prev j x✝¹ x✝ = result → LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij✝² = result
ij✝¹ : i.prev < j
ij✝ : ↑i ≤ ↑j
ij : ↑i < ↑j
⊢ arr[j] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
let swapped := arr.swap i j
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have sf : swapped[first] = arr[first] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt fi
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt (Nat.lt_of_lt_of_le fi ij)
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
let result := partitionImpl swapped first i.prev j.prev (by assumption) (by assumption)
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result✝ : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result✝
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ LoopInvariant result✝.snd first first ⟨↑result✝.fst.val, ⋯⟩ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
⊢ LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
subst eq
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result✝ : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result✝
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ LoopInvariant result✝.snd first first ⟨↑result✝.fst.val, ⋯⟩ last
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ LoopInvariant (partitionImpl arr first i j fi✝ ij).snd first first ⟨↑(partitionImpl arr first i j fi✝ ij).fst.val, ⋯⟩
last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result✝ : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result✝
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ LoopInvariant result✝.snd first first ⟨↑result✝.fst.val, ⋯⟩ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
simp [*]
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ LoopInvariant (partitionImpl arr first i j fi✝ ij).snd first first ⟨↑(partitionImpl arr first i j fi✝ ij).fst.val, ⋯⟩
last
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ LoopInvariant (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).snd first first
(partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).1.val last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ LoopInvariant (partitionImpl arr first i j fi✝ ij).snd first first ⟨↑(partitionImpl arr first i j fi✝ ij).fst.val, ⋯⟩
last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have inv : LoopInvariant swapped first i.prev j.prev last := by
apply LoopInvariant.intro
. intro k ik kj
have ik : i.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ik
cases Nat.eq_or_lt_of_le ik with
| inl ik =>
have : swapped[k] = arr[j] := by
simp [Fin.eq_of_val_eq ik.symm]
apply Vec.get_swap_left
rw [this, sf]
exact inv.3 (Nat.lt_of_lt_of_le (Fin.eq_of_val_eq ik.symm ▸ kj) (Nat.sub_le ..))
| inr ik =>
have kj : k < j := (Nat.lt_of_lt_of_le kj (Nat.sub_le ..))
have : swapped[k] = arr[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt ik
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt kj
rw [this, sf]
exact inv.1 k ik kj
. intro k jk kl
have jk : j.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi ij)))]
exact jk
cases Nat.eq_or_lt_of_le jk with
| inl jk =>
have : swapped[k] = arr[i] := by
simp [Fin.eq_of_val_eq jk.symm]
apply Vec.get_swap_right
rw [this, sf]
assumption
| inr jk =>
have : swapped[k] = arr[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk)
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt jk
rw [this, sf]
exact inv.2 k jk kl
. intro ij
have : j.val - 1 < j.val := by
show j.val - 1 + 1 ≤ j.val
rw [Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi (by assumption)))]
apply Nat.le_refl
have ij : i.val ≤ j.val - 1 := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ij
cases Nat.eq_or_lt_of_le ij with
| inl ij =>
have : swapped[j.prev] = arr[j] := by
simp [ij.symm, Fin.prev]
apply Vec.get_swap_left
rw [this, sf]
have : i < j := Nat.lt_of_le_of_lt (by assumption : i.val ≤ j.val - 1) (by assumption)
exact inv.3 this
| inr ij =>
have : swapped[j.prev] = arr[j.prev] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt ij
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt (by assumption)
rw [this, sf]
apply inv.1 j.prev ij (by assumption)
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ LoopInvariant (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).snd first first
(partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).1.val last
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv✝ : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
inv : LoopInvariant swapped first i.prev j.prev last
⊢ LoopInvariant (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).snd first first
(partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).1.val last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ LoopInvariant (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).snd first first
(partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).1.val last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact ih inv result (by rfl)
|
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv✝ : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
inv : LoopInvariant swapped first i.prev j.prev last
⊢ LoopInvariant (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).snd first first
(partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).1.val last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step_ge
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv✝ : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
inv : LoopInvariant swapped first i.prev j.prev last
⊢ LoopInvariant (partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).snd first first
(partitionImpl (arr.swap i j) first i.prev j.prev ⋯ ⋯).1.val last
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ swapped[first] = arr[first]
|
case ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ i
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ j
|
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ swapped[first] = arr[first]
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 fi
|
case ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ i
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ j
|
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ j
|
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ i
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ j
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 (Nat.lt_of_lt_of_le fi ij)
|
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ j
|
no goals
|
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ j
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ i
|
case ki.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ ¬↑first = ↑i
|
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ i
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact Nat.ne_of_lt fi
|
case ki.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ ¬↑first = ↑i
|
no goals
|
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ ¬↑first = ↑i
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ j
|
case kj.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ ¬↑first = ↑j
|
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ first ≠ j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact Nat.ne_of_lt (Nat.lt_of_lt_of_le fi ij)
|
case kj.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ ¬↑first = ↑j
|
no goals
|
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
⊢ ¬↑first = ↑j
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
⊢ first ≤ i.prev
|
no goals
|
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
⊢ first ≤ i.prev
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
⊢ i.prev ≤ j.prev
|
no goals
|
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
result : { mid // first ≤ mid ∧ mid ≤ j } × Vec α n
eq : partitionImpl arr first i j fi✝ ij = result
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
⊢ i.prev ≤ j.prev
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
apply LoopInvariant.intro
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ LoopInvariant swapped first i.prev j.prev last
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ ∀ (k : Fin n), i.prev < k → k < j.prev → swapped[k] < swapped[first]
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
|
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✝
⊢ LoopInvariant swapped first i.prev j.prev last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
. intro k ik kj
have ik : i.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ik
cases Nat.eq_or_lt_of_le ik with
| inl ik =>
have : swapped[k] = arr[j] := by
simp [Fin.eq_of_val_eq ik.symm]
apply Vec.get_swap_left
rw [this, sf]
exact inv.3 (Nat.lt_of_lt_of_le (Fin.eq_of_val_eq ik.symm ▸ kj) (Nat.sub_le ..))
| inr ik =>
have kj : k < j := (Nat.lt_of_lt_of_le kj (Nat.sub_le ..))
have : swapped[k] = arr[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt ik
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt kj
rw [this, sf]
exact inv.1 k ik kj
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ ∀ (k : Fin n), i.prev < k → k < j.prev → swapped[k] < swapped[first]
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
|
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✝
⊢ ∀ (k : Fin n), i.prev < k → k < j.prev → swapped[k] < swapped[first]
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
. intro k jk kl
have jk : j.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi ij)))]
exact jk
cases Nat.eq_or_lt_of_le jk with
| inl jk =>
have : swapped[k] = arr[i] := by
simp [Fin.eq_of_val_eq jk.symm]
apply Vec.get_swap_right
rw [this, sf]
assumption
| inr jk =>
have : swapped[k] = arr[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk)
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt jk
rw [this, sf]
exact inv.2 k jk kl
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
|
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✝
⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first]
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
. intro ij
have : j.val - 1 < j.val := by
show j.val - 1 + 1 ≤ j.val
rw [Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi (by assumption)))]
apply Nat.le_refl
have ij : i.val ≤ j.val - 1 := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ij
cases Nat.eq_or_lt_of_le ij with
| inl ij =>
have : swapped[j.prev] = arr[j] := by
simp [ij.symm, Fin.prev]
apply Vec.get_swap_left
rw [this, sf]
have : i < j := Nat.lt_of_le_of_lt (by assumption : i.val ≤ j.val - 1) (by assumption)
exact inv.3 this
| inr ij =>
have : swapped[j.prev] = arr[j.prev] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt ij
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt (by assumption)
rw [this, sf]
apply inv.1 j.prev ij (by assumption)
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
|
no goals
|
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✝
⊢ i.prev < 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]
|
intro k ik kj
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ ∀ (k : Fin n), i.prev < k → k < j.prev → swapped[k] < swapped[first]
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik : i.prev < k
kj : k < j.prev
⊢ swapped[k] < swapped[first]
|
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✝
⊢ ∀ (k : Fin n), i.prev < k → k < j.prev → swapped[k] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have ik : i.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt fi)]
exact ik
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik : i.prev < k
kj : k < j.prev
⊢ swapped[k] < swapped[first]
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝ : i.prev < k
kj : k < j.prev
ik : ↑i ≤ ↑k
⊢ swapped[k] < swapped[first]
|
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✝
k : Fin n
ik : i.prev < k
kj : k < j.prev
⊢ swapped[k] < 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 ik with
| inl ik =>
have : swapped[k] = arr[j] := by
simp [Fin.eq_of_val_eq ik.symm]
apply Vec.get_swap_left
rw [this, sf]
exact inv.3 (Nat.lt_of_lt_of_le (Fin.eq_of_val_eq ik.symm ▸ kj) (Nat.sub_le ..))
| inr ik =>
have kj : k < j := (Nat.lt_of_lt_of_le kj (Nat.sub_le ..))
have : swapped[k] = arr[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt ik
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt kj
rw [this, sf]
exact inv.1 k ik kj
|
case inv₁
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝ : i.prev < k
kj : k < j.prev
ik : ↑i ≤ ↑k
⊢ swapped[k] < swapped[first]
|
no goals
|
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✝
k : Fin n
ik✝ : i.prev < k
kj : k < j.prev
ik : ↑i ≤ ↑k
⊢ swapped[k] < swapped[first]
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✝
k : Fin n
ik : i.prev < k
kj : k < j.prev
⊢ ↑i ≤ ↑k
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik : i.prev < k
kj : k < j.prev
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑k
|
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✝
k : Fin n
ik : i.prev < k
kj : k < j.prev
⊢ ↑i ≤ ↑k
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact ik
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik : i.prev < k
kj : k < j.prev
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑k
|
no goals
|
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✝
k : Fin n
ik : i.prev < k
kj : k < j.prev
⊢ ↑i - Nat.succ 0 + Nat.succ 0 ≤ ↑k
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have : swapped[k] = arr[j] := by
simp [Fin.eq_of_val_eq ik.symm]
apply Vec.get_swap_left
|
case inv₁.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
⊢ swapped[k] < swapped[first]
|
case inv₁.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
this : swapped[k] = arr[j]
⊢ swapped[k] < swapped[first]
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
⊢ swapped[k] < 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✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
this : swapped[k] = arr[j]
⊢ swapped[k] < swapped[first]
|
case inv₁.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
this : swapped[k] = arr[j]
⊢ arr[j] < arr[first]
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
this : swapped[k] = arr[j]
⊢ swapped[k] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact inv.3 (Nat.lt_of_lt_of_le (Fin.eq_of_val_eq ik.symm ▸ kj) (Nat.sub_le ..))
|
case inv₁.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
this : swapped[k] = arr[j]
⊢ arr[j] < arr[first]
|
no goals
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
this : swapped[k] = arr[j]
⊢ arr[j] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
simp [Fin.eq_of_val_eq ik.symm]
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
⊢ swapped[k] = arr[j]
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
⊢ swapped[i] = arr[j]
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
⊢ swapped[k] = 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✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
⊢ 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✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i = ↑k
⊢ swapped[i] = arr[j]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have kj : k < j := (Nat.lt_of_lt_of_le kj (Nat.sub_le ..))
|
case inv₁.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
⊢ swapped[k] < swapped[first]
|
case inv₁.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ swapped[k] < swapped[first]
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
⊢ swapped[k] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have : swapped[k] = arr[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt ik
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt kj
|
case inv₁.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ swapped[k] < swapped[first]
|
case inv₁.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
this : swapped[k] = arr[k]
⊢ swapped[k] < swapped[first]
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ swapped[k] < 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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
this : swapped[k] = arr[k]
⊢ swapped[k] < swapped[first]
|
case inv₁.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
this : swapped[k] = arr[k]
⊢ arr[k] < arr[first]
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
this : swapped[k] = arr[k]
⊢ swapped[k] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact inv.1 k ik kj
|
case inv₁.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
this : swapped[k] = arr[k]
⊢ arr[k] < arr[first]
|
no goals
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
this : swapped[k] = arr[k]
⊢ arr[k] < arr[first]
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ swapped[k] = arr[k]
|
case ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ i
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ j
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ swapped[k] = arr[k]
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 ik
|
case ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ i
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ j
|
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ j
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ i
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ j
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 kj
|
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ j
|
no goals
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ 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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ i
|
case ki.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ ¬↑k = ↑i
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ i
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact Nat.ne_of_gt ik
|
case ki.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ ¬↑k = ↑i
|
no goals
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ ¬↑k = ↑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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ j
|
case kj.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ ¬↑k = ↑j
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ k ≠ j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact Nat.ne_of_lt kj
|
case kj.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ ¬↑k = ↑j
|
no goals
|
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✝
k : Fin n
ik✝¹ : i.prev < k
kj✝ : k < j.prev
ik✝ : ↑i ≤ ↑k
ik : ↑i < ↑k
kj : k < j
⊢ ¬↑k = ↑j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
intro k jk kl
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first]
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk : j.prev < k
kl : k ≤ last
⊢ ¬swapped[k] < swapped[first]
|
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✝
⊢ ∀ (k : Fin n), j.prev < k → k ≤ last → ¬swapped[k] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have jk : j.val ≤ k.val := by
rw [←Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi ij)))]
exact jk
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk : j.prev < k
kl : k ≤ last
⊢ ¬swapped[k] < swapped[first]
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝ : j.prev < k
kl : k ≤ last
jk : ↑j ≤ ↑k
⊢ ¬swapped[k] < swapped[first]
|
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✝
k : Fin n
jk : j.prev < k
kl : k ≤ last
⊢ ¬swapped[k] < 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 jk with
| inl jk =>
have : swapped[k] = arr[i] := by
simp [Fin.eq_of_val_eq jk.symm]
apply Vec.get_swap_right
rw [this, sf]
assumption
| inr jk =>
have : swapped[k] = arr[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk)
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt jk
rw [this, sf]
exact inv.2 k jk kl
|
case inv₂
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝ : j.prev < k
kl : k ≤ last
jk : ↑j ≤ ↑k
⊢ ¬swapped[k] < swapped[first]
|
no goals
|
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✝
k : Fin n
jk✝ : j.prev < k
kl : k ≤ last
jk : ↑j ≤ ↑k
⊢ ¬swapped[k] < swapped[first]
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.zero_lt_of_lt (Nat.lt_of_lt_of_le fi ij)))]
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk : j.prev < k
kl : k ≤ last
⊢ ↑j ≤ ↑k
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk : j.prev < k
kl : k ≤ last
⊢ ↑j - Nat.succ 0 + Nat.succ 0 ≤ ↑k
|
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✝
k : Fin n
jk : j.prev < k
kl : k ≤ last
⊢ ↑j ≤ ↑k
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact jk
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk : j.prev < k
kl : k ≤ last
⊢ ↑j - Nat.succ 0 + Nat.succ 0 ≤ ↑k
|
no goals
|
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✝
k : Fin n
jk : j.prev < k
kl : k ≤ last
⊢ ↑j - Nat.succ 0 + Nat.succ 0 ≤ ↑k
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have : swapped[k] = arr[i] := by
simp [Fin.eq_of_val_eq jk.symm]
apply Vec.get_swap_right
|
case inv₂.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
⊢ ¬swapped[k] < swapped[first]
|
case inv₂.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
this : swapped[k] = arr[i]
⊢ ¬swapped[k] < swapped[first]
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
⊢ ¬swapped[k] < 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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
this : swapped[k] = arr[i]
⊢ ¬swapped[k] < swapped[first]
|
case inv₂.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
this : swapped[k] = arr[i]
⊢ ¬arr[i] < arr[first]
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
this : swapped[k] = arr[i]
⊢ ¬swapped[k] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
assumption
|
case inv₂.inl
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
this : swapped[k] = arr[i]
⊢ ¬arr[i] < arr[first]
|
no goals
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
this : swapped[k] = arr[i]
⊢ ¬arr[i] < arr[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
simp [Fin.eq_of_val_eq jk.symm]
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
⊢ swapped[k] = arr[i]
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
⊢ swapped[j] = arr[i]
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
⊢ swapped[k] = arr[i]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
apply Vec.get_swap_right
|
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
⊢ swapped[j] = arr[i]
|
no goals
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j = ↑k
⊢ swapped[j] = arr[i]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
have : swapped[k] = arr[k] := by
apply Vec.get_swap_neq
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk)
. apply Fin.ne_of_val_ne
exact Nat.ne_of_gt jk
|
case inv₂.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ ¬swapped[k] < swapped[first]
|
case inv₂.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
this : swapped[k] = arr[k]
⊢ ¬swapped[k] < swapped[first]
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ ¬swapped[k] < 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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
this : swapped[k] = arr[k]
⊢ ¬swapped[k] < swapped[first]
|
case inv₂.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
this : swapped[k] = arr[k]
⊢ ¬arr[k] < arr[first]
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
this : swapped[k] = arr[k]
⊢ ¬swapped[k] < swapped[first]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact inv.2 k jk kl
|
case inv₂.inr
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
this : swapped[k] = arr[k]
⊢ ¬arr[k] < arr[first]
|
no goals
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
this : swapped[k] = arr[k]
⊢ ¬arr[k] < arr[first]
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ swapped[k] = arr[k]
|
case ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ i
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ j
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ swapped[k] = arr[k]
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 (Nat.lt_of_le_of_lt ij jk)
|
case ki
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ i
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ j
|
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ j
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ i
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ j
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 jk
|
case kj
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ j
|
no goals
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ 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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ i
|
case ki.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ ¬↑k = ↑i
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ i
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact Nat.ne_of_gt (Nat.lt_of_le_of_lt ij jk)
|
case ki.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ ¬↑k = ↑i
|
no goals
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ ¬↑k = ↑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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ j
|
case kj.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ ¬↑k = ↑j
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ k ≠ j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
exact Nat.ne_of_gt jk
|
case kj.h
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ ¬↑k = ↑j
|
no goals
|
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✝
k : Fin n
jk✝¹ : j.prev < k
kl : k ≤ last
jk✝ : ↑j ≤ ↑k
jk : ↑j < ↑k
⊢ ¬↑k = ↑j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Sorted.lean
|
partitionImpl.loop_invariant
|
[21, 1]
|
[141, 33]
|
intro ij
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
⊢ i.prev < j.prev → swapped[j.prev] < swapped[first]
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
ij : i.prev < j.prev
⊢ swapped[j.prev] < swapped[first]
|
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✝
⊢ i.prev < 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]
|
have : j.val - 1 < j.val := by
show j.val - 1 + 1 ≤ j.val
rw [Nat.sub_add_cancel (Nat.zero_lt_of_lt (Nat.lt_of_lt_of_le fi (by assumption)))]
apply Nat.le_refl
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
ij : i.prev < j.prev
⊢ swapped[j.prev] < swapped[first]
|
case inv₃
α : Type
inst✝ : Ord α
n : Nat
first✝ i✝ j✝ last : Fin n
arr : Vec α n
first i j : Fin n
fi✝ : first ≤ i
ij✝ : i ≤ j
fi : first < i
x✝² : ↑first ≤ ↑i - 1
x✝¹ : ¬arr[i] < arr[first]
x✝ : ↑i - 1 ≤ ↑j - 1
ih :
LoopInvariant (arr.swap i j) first i.prev j.prev last →
∀ (result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n),
partitionImpl (arr.swap i j) first i.prev j.prev x✝² x✝ = result →
LoopInvariant result.snd first first ⟨↑result.fst.val, ⋯⟩ last
inv : LoopInvariant arr first i j last
swapped : Vec α n := arr.swap i j
sf : swapped[first] = arr[first]
result : { mid // first ≤ mid ∧ mid ≤ j.prev } × Vec α n := partitionImpl swapped first i.prev j.prev x✝² x✝
ij : i.prev < j.prev
this : ↑j - 1 < ↑j
⊢ swapped[j.prev] < swapped[first]
|
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
⊢ swapped[j.prev] < swapped[first]
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.