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/Permutation.lean
|
invertible_id
|
[8, 1]
|
[15, 19]
|
exact ⟨id, this⟩
|
α : Sort u_1
this : isInv id id
⊢ invertible id
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Sort u_1
this : isInv id id
⊢ invertible id
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
invertible_id
|
[8, 1]
|
[15, 19]
|
apply And.intro
|
α : Sort u_1
⊢ isInv id id
|
case left
α : Sort u_1
⊢ ∀ (x : α), id (id x) = x
case right
α : Sort u_1
⊢ ∀ (y : α), id (id y) = y
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Sort u_1
⊢ isInv id id
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
invertible_id
|
[8, 1]
|
[15, 19]
|
. intro x
simp
|
case left
α : Sort u_1
⊢ ∀ (x : α), id (id x) = x
case right
α : Sort u_1
⊢ ∀ (y : α), id (id y) = y
|
case right
α : Sort u_1
⊢ ∀ (y : α), id (id y) = y
|
Please generate a tactic in lean4 to solve the state.
STATE:
case left
α : Sort u_1
⊢ ∀ (x : α), id (id x) = x
case right
α : Sort u_1
⊢ ∀ (y : α), id (id y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
invertible_id
|
[8, 1]
|
[15, 19]
|
. intro y
simp
|
case right
α : Sort u_1
⊢ ∀ (y : α), id (id y) = y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case right
α : Sort u_1
⊢ ∀ (y : α), id (id y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
invertible_id
|
[8, 1]
|
[15, 19]
|
intro x
|
case left
α : Sort u_1
⊢ ∀ (x : α), id (id x) = x
|
case left
α : Sort u_1
x : α
⊢ id (id x) = x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case left
α : Sort u_1
⊢ ∀ (x : α), id (id x) = x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
invertible_id
|
[8, 1]
|
[15, 19]
|
simp
|
case left
α : Sort u_1
x : α
⊢ id (id x) = x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case left
α : Sort u_1
x : α
⊢ id (id x) = x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
invertible_id
|
[8, 1]
|
[15, 19]
|
intro y
|
case right
α : Sort u_1
⊢ ∀ (y : α), id (id y) = y
|
case right
α : Sort u_1
y : α
⊢ id (id y) = y
|
Please generate a tactic in lean4 to solve the state.
STATE:
case right
α : Sort u_1
⊢ ∀ (y : α), id (id y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
invertible_id
|
[8, 1]
|
[15, 19]
|
simp
|
case right
α : Sort u_1
y : α
⊢ id (id y) = y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case right
α : Sort u_1
y : α
⊢ id (id y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
induction p with
| refl => simp [permuted.to_map, invertible_id]
| step i j fi ij jl p ih =>
let ⟨f', ⟨h1, h2⟩⟩ := ih
let f := permuted.to_map (permuted.step i j fi ij jl p)
show invertible f
let g := fun (k : Fin n) =>
let k' := f' k
if k' = i then j
else if k' = j then i
else k'
have gf : ∀x, g (f x) = x := by
intro x
simp (config := {zeta := false}) [f, permuted.to_map]
cases decEq x i with
| isFalse nxi =>
cases decEq x j with
| isFalse nxj => simp [nxi, nxj, g, h1]
| isTrue xj => simp [nxi, xj, g, h1]
| isTrue xi => simp [xi, g, h1]
have fg : ∀y, f (g y) = y := by
intro y
simp (config := {zeta := false}) [g]
show f (if f' y = i then j else if f' y = j then i else f' y) = y
cases decEq (f' y) i with
| isFalse nfyi =>
cases decEq (f' y) j with
| isFalse nfyj => simp [nfyi, nfyj, permuted.to_map, h2, f]
| isTrue fyj =>
simp [nfyi, fyj, permuted.to_map, f]
rw [←(congrArg p.to_map fyj), h2]
| isTrue fyi =>
simp [fyi, f, permuted.to_map]
have : (if j = i then j else i) = i := by simp
rw [this, ←(congrArg p.to_map fyi), h2]
exact ⟨g, ⟨gf, fg⟩⟩
|
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
p : permuted n first last arr1 arr2
⊢ invertible p.to_map
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
p : permuted n first last arr1 arr2
⊢ invertible p.to_map
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
simp [permuted.to_map, invertible_id]
|
case refl
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ : Vec α✝ n
⊢ invertible permuted.refl.to_map
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case refl
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ : Vec α✝ n
⊢ invertible permuted.refl.to_map
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
let ⟨f', ⟨h1, h2⟩⟩ := ih
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
⊢ invertible (permuted.step i j fi ij jl p).to_map
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
⊢ invertible (permuted.step i j fi ij jl p).to_map
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
⊢ invertible (permuted.step i j fi ij jl p).to_map
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
let f := permuted.to_map (permuted.step i j fi ij jl p)
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
⊢ invertible (permuted.step i j fi ij jl p).to_map
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
⊢ invertible (permuted.step i j fi ij jl p).to_map
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
⊢ invertible (permuted.step i j fi ij jl p).to_map
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
show invertible f
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
⊢ invertible (permuted.step i j fi ij jl p).to_map
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
⊢ invertible f
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
⊢ invertible (permuted.step i j fi ij jl p).to_map
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
let g := fun (k : Fin n) =>
let k' := f' k
if k' = i then j
else if k' = j then i
else k'
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
⊢ invertible f
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
⊢ invertible f
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
⊢ invertible f
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
have gf : ∀x, g (f x) = x := by
intro x
simp (config := {zeta := false}) [f, permuted.to_map]
cases decEq x i with
| isFalse nxi =>
cases decEq x j with
| isFalse nxj => simp [nxi, nxj, g, h1]
| isTrue xj => simp [nxi, xj, g, h1]
| isTrue xi => simp [xi, g, h1]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
⊢ invertible f
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
⊢ invertible f
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
⊢ invertible f
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
have fg : ∀y, f (g y) = y := by
intro y
simp (config := {zeta := false}) [g]
show f (if f' y = i then j else if f' y = j then i else f' y) = y
cases decEq (f' y) i with
| isFalse nfyi =>
cases decEq (f' y) j with
| isFalse nfyj => simp [nfyi, nfyj, permuted.to_map, h2, f]
| isTrue fyj =>
simp [nfyi, fyj, permuted.to_map, f]
rw [←(congrArg p.to_map fyj), h2]
| isTrue fyi =>
simp [fyi, f, permuted.to_map]
have : (if j = i then j else i) = i := by simp
rw [this, ←(congrArg p.to_map fyi), h2]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
⊢ invertible f
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
fg : ∀ (y : Fin n), f (g y) = y
⊢ invertible f
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
⊢ invertible f
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
exact ⟨g, ⟨gf, fg⟩⟩
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
fg : ∀ (y : Fin n), f (g y) = y
⊢ invertible f
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
fg : ∀ (y : Fin n), f (g y) = y
⊢ invertible f
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
intro x
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
⊢ ∀ (x : Fin n), g (f x) = x
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
⊢ g (f x) = x
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
⊢ ∀ (x : Fin n), g (f x) = x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
simp (config := {zeta := false}) [f, permuted.to_map]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
⊢ g (f x) = x
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
⊢ g (f x) = x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
cases decEq x i with
| isFalse nxi =>
cases decEq x j with
| isFalse nxj => simp [nxi, nxj, g, h1]
| isTrue xj => simp [nxi, xj, g, h1]
| isTrue xi => simp [xi, g, h1]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
cases decEq x j with
| isFalse nxj => simp [nxi, nxj, g, h1]
| isTrue xj => simp [nxi, xj, g, h1]
|
case isFalse
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
nxi : ¬x = i
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isFalse
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
nxi : ¬x = i
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
simp [nxi, nxj, g, h1]
|
case isFalse.isFalse
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
nxi : ¬x = i
nxj : ¬x = j
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isFalse.isFalse
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
nxi : ¬x = i
nxj : ¬x = j
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
simp [nxi, xj, g, h1]
|
case isFalse.isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
nxi : ¬x = i
xj : x = j
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isFalse.isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
nxi : ¬x = i
xj : x = j
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
simp [xi, g, h1]
|
case isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
xi : x = i
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
x : Fin n
xi : x = i
⊢ g
(let k' := if x = i then j else if x = j then i else x;
p.to_map k') =
x
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
intro y
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
⊢ ∀ (y : Fin n), f (g y) = y
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
⊢ f (g y) = y
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
⊢ ∀ (y : Fin n), f (g y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
simp (config := {zeta := false}) [g]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
⊢ f (g y) = y
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
⊢ f
(let k' := f' y;
if k' = i then j else if k' = j then i else k') =
y
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
⊢ f (g y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
show f (if f' y = i then j else if f' y = j then i else f' y) = y
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
⊢ f
(let k' := f' y;
if k' = i then j else if k' = j then i else k') =
y
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
⊢ f
(let k' := f' y;
if k' = i then j else if k' = j then i else k') =
y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
cases decEq (f' y) i with
| isFalse nfyi =>
cases decEq (f' y) j with
| isFalse nfyj => simp [nfyi, nfyj, permuted.to_map, h2, f]
| isTrue fyj =>
simp [nfyi, fyj, permuted.to_map, f]
rw [←(congrArg p.to_map fyj), h2]
| isTrue fyi =>
simp [fyi, f, permuted.to_map]
have : (if j = i then j else i) = i := by simp
rw [this, ←(congrArg p.to_map fyi), h2]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
cases decEq (f' y) j with
| isFalse nfyj => simp [nfyi, nfyj, permuted.to_map, h2, f]
| isTrue fyj =>
simp [nfyi, fyj, permuted.to_map, f]
rw [←(congrArg p.to_map fyj), h2]
|
case isFalse
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
nfyi : ¬f' y = i
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isFalse
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
nfyi : ¬f' y = i
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
simp [nfyi, nfyj, permuted.to_map, h2, f]
|
case isFalse.isFalse
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
nfyi : ¬f' y = i
nfyj : ¬f' y = j
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isFalse.isFalse
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
nfyi : ¬f' y = i
nfyj : ¬f' y = j
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
simp [nfyi, fyj, permuted.to_map, f]
|
case isFalse.isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
nfyi : ¬f' y = i
fyj : f' y = j
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
|
case isFalse.isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
nfyi : ¬f' y = i
fyj : f' y = j
⊢ p.to_map j = y
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isFalse.isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
nfyi : ¬f' y = i
fyj : f' y = j
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
rw [←(congrArg p.to_map fyj), h2]
|
case isFalse.isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
nfyi : ¬f' y = i
fyj : f' y = j
⊢ p.to_map j = y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isFalse.isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
nfyi : ¬f' y = i
fyj : f' y = j
⊢ p.to_map j = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
simp [fyi, f, permuted.to_map]
|
case isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
fyi : f' y = i
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
|
case isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
fyi : f' y = i
⊢ p.to_map (if j = i then j else i) = y
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
fyi : f' y = i
⊢ f (if f' y = i then j else if f' y = j then i else f' y) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
have : (if j = i then j else i) = i := by simp
|
case isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
fyi : f' y = i
⊢ p.to_map (if j = i then j else i) = y
|
case isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
fyi : f' y = i
this : (if j = i then j else i) = i
⊢ p.to_map (if j = i then j else i) = y
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
fyi : f' y = i
⊢ p.to_map (if j = i then j else i) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
rw [this, ←(congrArg p.to_map fyi), h2]
|
case isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
fyi : f' y = i
this : (if j = i then j else i) = i
⊢ p.to_map (if j = i then j else i) = y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case isTrue
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
fyi : f' y = i
this : (if j = i then j else i) = i
⊢ p.to_map (if j = i then j else i) = y
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_invertible
|
[51, 1]
|
[87, 24]
|
simp
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
fyi : f' y = i
⊢ (if j = i then j else i) = i
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : invertible p.to_map
f' : Fin n → Fin n
h1 : ∀ (x : Fin n), f' (p.to_map x) = x
h2 : ∀ (y : Fin n), p.to_map (f' y) = y
f : Fin n → Fin n := (permuted.step i j fi ij jl p).to_map
g : Fin n → Fin n :=
fun k =>
let k' := f' k;
if k' = i then j else if k' = j then i else k'
gf : ∀ (x : Fin n), g (f x) = x
y : Fin n
fyi : f' y = i
⊢ (if j = i then j else i) = i
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
induction p generalizing k with
| refl => simp [permuted.to_map]
| step i j fi ij jl p ih =>
simp [permuted.to_map]
rw [←ih]
split
case step.inl ki => simp [ki, Vec.get_swap_right]
case step.inr nki =>
split
case inl kj => simp [kj, Vec.get_swap_left]
case inr nkj => rw [Vec.get_swap_neq _ i j k nki nkj]
|
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
p : permuted n first last arr1 arr2
k : Fin n
⊢ arr1[k] = arr2[p.to_map k]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
p : permuted n first last arr1 arr2
k : Fin n
⊢ arr1[k] = arr2[p.to_map k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
simp [permuted.to_map]
|
case refl
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ : Vec α✝ n
k : Fin n
⊢ arr✝[k] = arr✝[permuted.refl.to_map k]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case refl
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ : Vec α✝ n
k : Fin n
⊢ arr✝[k] = arr✝[permuted.refl.to_map k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
simp [permuted.to_map]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
⊢ arr✝[k] = arr'✝[(permuted.step i j fi ij jl p).to_map k]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
⊢ arr✝[k] = arr'✝[p.to_map (if k = i then j else if k = j then i else k)]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
⊢ arr✝[k] = arr'✝[(permuted.step i j fi ij jl p).to_map k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
rw [←ih]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
⊢ arr✝[k] = arr'✝[p.to_map (if k = i then j else if k = j then i else k)]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
⊢ arr✝[k] = (arr✝.swap i j)[if k = i then j else if k = j then i else k]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
⊢ arr✝[k] = arr'✝[p.to_map (if k = i then j else if k = j then i else k)]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
split
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
⊢ arr✝[k] = (arr✝.swap i j)[if k = i then j else if k = j then i else k]
|
case step.inl
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
h✝ : k = i
⊢ arr✝[k] = (arr✝.swap i j)[j]
case step.inr
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
h✝ : ¬k = i
⊢ arr✝[k] = (arr✝.swap i j)[if k = j then i else k]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
⊢ arr✝[k] = (arr✝.swap i j)[if k = i then j else if k = j then i else k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
case step.inl ki => simp [ki, Vec.get_swap_right]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
ki : k = i
⊢ arr✝[k] = (arr✝.swap i j)[j]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
ki : k = i
⊢ arr✝[k] = (arr✝.swap i j)[j]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
case step.inr nki =>
split
case inl kj => simp [kj, Vec.get_swap_left]
case inr nkj => rw [Vec.get_swap_neq _ i j k nki nkj]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
⊢ arr✝[k] = (arr✝.swap i j)[if k = j then i else k]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
⊢ arr✝[k] = (arr✝.swap i j)[if k = j then i else k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
simp [ki, Vec.get_swap_right]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
ki : k = i
⊢ arr✝[k] = (arr✝.swap i j)[j]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
ki : k = i
⊢ arr✝[k] = (arr✝.swap i j)[j]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
split
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
⊢ arr✝[k] = (arr✝.swap i j)[if k = j then i else k]
|
case inl
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
h✝ : k = j
⊢ arr✝[k] = (arr✝.swap i j)[i]
case inr
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
h✝ : ¬k = j
⊢ arr✝[k] = (arr✝.swap i j)[k]
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
⊢ arr✝[k] = (arr✝.swap i j)[if k = j then i else k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
case inl kj => simp [kj, Vec.get_swap_left]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
kj : k = j
⊢ arr✝[k] = (arr✝.swap i j)[i]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
kj : k = j
⊢ arr✝[k] = (arr✝.swap i j)[i]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
case inr nkj => rw [Vec.get_swap_neq _ i j k nki nkj]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
nkj : ¬k = j
⊢ arr✝[k] = (arr✝.swap i j)[k]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
nkj : ¬k = j
⊢ arr✝[k] = (arr✝.swap i j)[k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
simp [kj, Vec.get_swap_left]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
kj : k = j
⊢ arr✝[k] = (arr✝.swap i j)[i]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
kj : k = j
⊢ arr✝[k] = (arr✝.swap i j)[i]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index
|
[89, 1]
|
[101, 60]
|
rw [Vec.get_swap_neq _ i j k nki nkj]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
nkj : ¬k = j
⊢ arr✝[k] = (arr✝.swap i j)[k]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), (arr✝.swap i j)[k] = arr'✝[p.to_map k]
k : Fin n
nki : ¬k = i
nkj : ¬k = j
⊢ arr✝[k] = (arr✝.swap i j)[k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_invertible
|
[103, 1]
|
[110, 33]
|
exists p.to_map
|
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ ∃ f, invertible f ∧ ∀ (i : Fin n), arr[i] = arr'[f i]
|
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ invertible p.to_map ∧ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ ∃ f, invertible f ∧ ∀ (i : Fin n), arr[i] = arr'[f i]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_invertible
|
[103, 1]
|
[110, 33]
|
apply And.intro
|
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ invertible p.to_map ∧ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
|
case left
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ invertible p.to_map
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ invertible p.to_map ∧ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_invertible
|
[103, 1]
|
[110, 33]
|
. exact permuted_map_invertible p
|
case left
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ invertible p.to_map
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
|
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case left
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ invertible p.to_map
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_invertible
|
[103, 1]
|
[110, 33]
|
. intro i
exact permuted_map_index p i
|
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_invertible
|
[103, 1]
|
[110, 33]
|
exact permuted_map_invertible p
|
case left
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ invertible p.to_map
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case left
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ invertible p.to_map
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_invertible
|
[103, 1]
|
[110, 33]
|
intro i
|
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
|
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
i : Fin n
⊢ arr[i] = arr'[p.to_map i]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
⊢ ∀ (i : Fin n), arr[i] = arr'[p.to_map i]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_invertible
|
[103, 1]
|
[110, 33]
|
exact permuted_map_index p i
|
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
i : Fin n
⊢ arr[i] = arr'[p.to_map i]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case right
α : Type
n first last : Nat
arr arr' : Vec α n
p : permuted n first last arr arr'
i : Fin n
⊢ arr[i] = arr'[p.to_map i]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
induction p generalizing k with
| refl => simp [permuted.to_map, fk, kl]
| step i j fi ij jl p ih =>
simp [permuted.to_map]
let k' := if k = i then j else if k = j then i else k
have : first ≤ k'.val ∧ k'.val ≤ last := by
match decEq k i, decEq k j with
| isTrue ki, _ =>
simp [k', ki]
exact ⟨Nat.le_trans fi ij, jl⟩
| isFalse ki, isTrue kj =>
simp [k', ki]
simp [kj]
exact ⟨fi, Nat.le_trans ij jl⟩
| isFalse ki, isFalse kj =>
simp [k', ki, kj]
exact ⟨fk, kl⟩
exact ih k' this.1 this.2
|
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
p : permuted n first last arr1 arr2
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
p : permuted n first last arr1 arr2
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
simp [permuted.to_map, fk, kl]
|
case refl
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ : Vec α✝ n
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ first ≤ ↑(permuted.refl.to_map k) ∧ ↑(permuted.refl.to_map k) ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case refl
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ : Vec α✝ n
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ first ≤ ↑(permuted.refl.to_map k) ∧ ↑(permuted.refl.to_map k) ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
simp [permuted.to_map]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ first ≤ ↑((permuted.step i j fi ij jl p).to_map k) ∧ ↑((permuted.step i j fi ij jl p).to_map k) ≤ last
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ first ≤ ↑(p.to_map (if k = i then j else if k = j then i else k)) ∧
↑(p.to_map (if k = i then j else if k = j then i else k)) ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ first ≤ ↑((permuted.step i j fi ij jl p).to_map k) ∧ ↑((permuted.step i j fi ij jl p).to_map k) ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
let k' := if k = i then j else if k = j then i else k
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ first ≤ ↑(p.to_map (if k = i then j else if k = j then i else k)) ∧
↑(p.to_map (if k = i then j else if k = j then i else k)) ≤ last
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
⊢ first ≤ ↑(p.to_map (if k = i then j else if k = j then i else k)) ∧
↑(p.to_map (if k = i then j else if k = j then i else k)) ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ first ≤ ↑(p.to_map (if k = i then j else if k = j then i else k)) ∧
↑(p.to_map (if k = i then j else if k = j then i else k)) ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
have : first ≤ k'.val ∧ k'.val ≤ last := by
match decEq k i, decEq k j with
| isTrue ki, _ =>
simp [k', ki]
exact ⟨Nat.le_trans fi ij, jl⟩
| isFalse ki, isTrue kj =>
simp [k', ki]
simp [kj]
exact ⟨fi, Nat.le_trans ij jl⟩
| isFalse ki, isFalse kj =>
simp [k', ki, kj]
exact ⟨fk, kl⟩
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
⊢ first ≤ ↑(p.to_map (if k = i then j else if k = j then i else k)) ∧
↑(p.to_map (if k = i then j else if k = j then i else k)) ≤ last
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
this : first ≤ ↑k' ∧ ↑k' ≤ last
⊢ first ≤ ↑(p.to_map (if k = i then j else if k = j then i else k)) ∧
↑(p.to_map (if k = i then j else if k = j then i else k)) ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
⊢ first ≤ ↑(p.to_map (if k = i then j else if k = j then i else k)) ∧
↑(p.to_map (if k = i then j else if k = j then i else k)) ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
exact ih k' this.1 this.2
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
this : first ≤ ↑k' ∧ ↑k' ≤ last
⊢ first ≤ ↑(p.to_map (if k = i then j else if k = j then i else k)) ∧
↑(p.to_map (if k = i then j else if k = j then i else k)) ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
this : first ≤ ↑k' ∧ ↑k' ≤ last
⊢ first ≤ ↑(p.to_map (if k = i then j else if k = j then i else k)) ∧
↑(p.to_map (if k = i then j else if k = j then i else k)) ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
match decEq k i, decEq k j with
| isTrue ki, _ =>
simp [k', ki]
exact ⟨Nat.le_trans fi ij, jl⟩
| isFalse ki, isTrue kj =>
simp [k', ki]
simp [kj]
exact ⟨fi, Nat.le_trans ij jl⟩
| isFalse ki, isFalse kj =>
simp [k', ki, kj]
exact ⟨fk, kl⟩
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
simp [k', ki]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : k = i
x✝ : Decidable (k = j)
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : k = i
x✝ : Decidable (k = j)
⊢ first ≤ ↑j ∧ ↑j ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : k = i
x✝ : Decidable (k = j)
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
exact ⟨Nat.le_trans fi ij, jl⟩
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : k = i
x✝ : Decidable (k = j)
⊢ first ≤ ↑j ∧ ↑j ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : k = i
x✝ : Decidable (k = j)
⊢ first ≤ ↑j ∧ ↑j ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
simp [k', ki]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : k = j
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : k = j
⊢ first ≤ ↑(if k = j then i else k) ∧ ↑(if k = j then i else k) ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : k = j
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
simp [kj]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : k = j
⊢ first ≤ ↑(if k = j then i else k) ∧ ↑(if k = j then i else k) ≤ last
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : k = j
⊢ first ≤ ↑i ∧ ↑i ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : k = j
⊢ first ≤ ↑(if k = j then i else k) ∧ ↑(if k = j then i else k) ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
exact ⟨fi, Nat.le_trans ij jl⟩
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : k = j
⊢ first ≤ ↑i ∧ ↑i ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : k = j
⊢ first ≤ ↑i ∧ ↑i ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
simp [k', ki, kj]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : ¬k = j
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : ¬k = j
⊢ first ≤ ↑k ∧ ↑k ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : ¬k = j
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range
|
[112, 1]
|
[132, 30]
|
exact ⟨fk, kl⟩
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : ¬k = j
⊢ first ≤ ↑k ∧ ↑k ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → first ≤ ↑(p.to_map k) ∧ ↑(p.to_map k) ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n := if k = i then j else if k = j then i else k
ki : ¬k = i
kj : ¬k = j
⊢ first ≤ ↑k ∧ ↑k ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
induction p generalizing k with
| refl => simp [permuted.to_map, fk, kl]
| step i j fi ij jl p ih =>
simp [permuted.to_map]
let ⟨k', ⟨index, fk', kl'⟩⟩ := ih k fk kl
let k'' := if k' = i then j else if k' = j then i else k'
exists k''
have : (if k'' = i then j else if k'' = j then i else k'') = k' := by
match decEq k' i, decEq k' j with
| isTrue ki, _ => simp [k'', ki]
| _, isTrue kj => simp [k'', kj]
| isFalse ki, isFalse kj => simp [k'',ki, kj]
rw [this]
have : first ≤ k''.val ∧ k''.val ≤ last := by
match decEq k' i, decEq k' j with
| isTrue ki, _ =>
simp [k'', ki]
exact ⟨Nat.le_trans fi ij, jl⟩
| isFalse ki, isTrue kj =>
simp [k'', ki]
simp [kj]
exact ⟨fi, Nat.le_trans ij jl⟩
| isFalse ki, isFalse kj =>
simp [k'', ki, kj]
exact ⟨fk', kl'⟩
exact ⟨index, this.1, this.2⟩
|
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
p : permuted n first last arr1 arr2
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
p : permuted n first last arr1 arr2
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
simp [permuted.to_map, fk, kl]
|
case refl
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ : Vec α✝ n
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ ∃ k', permuted.refl.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case refl
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ : Vec α✝ n
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ ∃ k', permuted.refl.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
simp [permuted.to_map]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ ∃ k', (permuted.step i j fi ij jl p).to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ ∃ k', p.to_map (if k' = i then j else if k' = j then i else k') = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ ∃ k', (permuted.step i j fi ij jl p).to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
let ⟨k', ⟨index, fk', kl'⟩⟩ := ih k fk kl
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ ∃ k', p.to_map (if k' = i then j else if k' = j then i else k') = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
⊢ ∃ k', p.to_map (if k' = i then j else if k' = j then i else k') = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
⊢ ∃ k', p.to_map (if k' = i then j else if k' = j then i else k') = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
let k'' := if k' = i then j else if k' = j then i else k'
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
⊢ ∃ k', p.to_map (if k' = i then j else if k' = j then i else k') = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
⊢ ∃ k', p.to_map (if k' = i then j else if k' = j then i else k') = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
⊢ ∃ k', p.to_map (if k' = i then j else if k' = j then i else k') = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
exists k''
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
⊢ ∃ k', p.to_map (if k' = i then j else if k' = j then i else k') = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
⊢ p.to_map (if k'' = i then j else if k'' = j then i else k'') = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
⊢ ∃ k', p.to_map (if k' = i then j else if k' = j then i else k') = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
have : (if k'' = i then j else if k'' = j then i else k'') = k' := by
match decEq k' i, decEq k' j with
| isTrue ki, _ => simp [k'', ki]
| _, isTrue kj => simp [k'', kj]
| isFalse ki, isFalse kj => simp [k'',ki, kj]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
⊢ p.to_map (if k'' = i then j else if k'' = j then i else k'') = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
⊢ p.to_map (if k'' = i then j else if k'' = j then i else k'') = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
⊢ p.to_map (if k'' = i then j else if k'' = j then i else k'') = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
rw [this]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
⊢ p.to_map (if k'' = i then j else if k'' = j then i else k'') = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
⊢ p.to_map k' = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
⊢ p.to_map (if k'' = i then j else if k'' = j then i else k'') = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
have : first ≤ k''.val ∧ k''.val ≤ last := by
match decEq k' i, decEq k' j with
| isTrue ki, _ =>
simp [k'', ki]
exact ⟨Nat.le_trans fi ij, jl⟩
| isFalse ki, isTrue kj =>
simp [k'', ki]
simp [kj]
exact ⟨fi, Nat.le_trans ij jl⟩
| isFalse ki, isFalse kj =>
simp [k'', ki, kj]
exact ⟨fk', kl'⟩
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
⊢ p.to_map k' = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this✝ : (if k'' = i then j else if k'' = j then i else k'') = k'
this : first ≤ ↑k'' ∧ ↑k'' ≤ last
⊢ p.to_map k' = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
⊢ p.to_map k' = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
exact ⟨index, this.1, this.2⟩
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this✝ : (if k'' = i then j else if k'' = j then i else k'') = k'
this : first ≤ ↑k'' ∧ ↑k'' ≤ last
⊢ p.to_map k' = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this✝ : (if k'' = i then j else if k'' = j then i else k'') = k'
this : first ≤ ↑k'' ∧ ↑k'' ≤ last
⊢ p.to_map k' = k ∧ first ≤ ↑k'' ∧ ↑k'' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
match decEq k' i, decEq k' j with
| isTrue ki, _ => simp [k'', ki]
| _, isTrue kj => simp [k'', kj]
| isFalse ki, isFalse kj => simp [k'',ki, kj]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
⊢ (if k'' = i then j else if k'' = j then i else k'') = k'
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
⊢ (if k'' = i then j else if k'' = j then i else k'') = k'
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
simp [k'', ki]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
ki : k' = i
x✝ : Decidable (k' = j)
⊢ (if k'' = i then j else if k'' = j then i else k'') = k'
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
ki : k' = i
x✝ : Decidable (k' = j)
⊢ (if k'' = i then j else if k'' = j then i else k'') = k'
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
simp [k'', kj]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
x✝ : Decidable (k' = i)
kj : k' = j
⊢ (if k'' = i then j else if k'' = j then i else k'') = k'
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
x✝ : Decidable (k' = i)
kj : k' = j
⊢ (if k'' = i then j else if k'' = j then i else k'') = k'
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
simp [k'',ki, kj]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
ki : ¬k' = i
kj : ¬k' = j
⊢ (if k'' = i then j else if k'' = j then i else k'') = k'
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
ki : ¬k' = i
kj : ¬k' = j
⊢ (if k'' = i then j else if k'' = j then i else k'') = k'
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
match decEq k' i, decEq k' j with
| isTrue ki, _ =>
simp [k'', ki]
exact ⟨Nat.le_trans fi ij, jl⟩
| isFalse ki, isTrue kj =>
simp [k'', ki]
simp [kj]
exact ⟨fi, Nat.le_trans ij jl⟩
| isFalse ki, isFalse kj =>
simp [k'', ki, kj]
exact ⟨fk', kl'⟩
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
⊢ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
⊢ first ≤ ↑k'' ∧ ↑k'' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
simp [k'', ki]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : k' = i
x✝ : Decidable (k' = j)
⊢ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : k' = i
x✝ : Decidable (k' = j)
⊢ first ≤ ↑j ∧ ↑j ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : k' = i
x✝ : Decidable (k' = j)
⊢ first ≤ ↑k'' ∧ ↑k'' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
exact ⟨Nat.le_trans fi ij, jl⟩
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : k' = i
x✝ : Decidable (k' = j)
⊢ first ≤ ↑j ∧ ↑j ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : k' = i
x✝ : Decidable (k' = j)
⊢ first ≤ ↑j ∧ ↑j ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
simp [k'', ki]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : k' = j
⊢ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : k' = j
⊢ first ≤ ↑(if k' = j then i else k') ∧ ↑(if k' = j then i else k') ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : k' = j
⊢ first ≤ ↑k'' ∧ ↑k'' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
simp [kj]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : k' = j
⊢ first ≤ ↑(if k' = j then i else k') ∧ ↑(if k' = j then i else k') ≤ last
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : k' = j
⊢ first ≤ ↑i ∧ ↑i ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : k' = j
⊢ first ≤ ↑(if k' = j then i else k') ∧ ↑(if k' = j then i else k') ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
exact ⟨fi, Nat.le_trans ij jl⟩
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : k' = j
⊢ first ≤ ↑i ∧ ↑i ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : k' = j
⊢ first ≤ ↑i ∧ ↑i ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
simp [k'', ki, kj]
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : ¬k' = j
⊢ first ≤ ↑k'' ∧ ↑k'' ≤ last
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : ¬k' = j
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : ¬k' = j
⊢ first ≤ ↑k'' ∧ ↑k'' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted_map_index_in_range_inv
|
[134, 1]
|
[165, 34]
|
exact ⟨fk', kl'⟩
|
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : ¬k' = j
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : ∀ (k : Fin n), first ≤ ↑k → ↑k ≤ last → ∃ k', p.to_map k' = k ∧ first ≤ ↑k' ∧ ↑k' ≤ last
k : Fin n
fk : first ≤ ↑k
kl : ↑k ≤ last
k' : Fin n
index : p.to_map k' = k
fk' : first ≤ ↑k'
kl' : ↑k' ≤ last
k'' : Fin n := if k' = i then j else if k' = j then i else k'
this : (if k'' = i then j else if k'' = j then i else k'') = k'
ki : ¬k' = i
kj : ¬k' = j
⊢ first ≤ ↑k' ∧ ↑k' ≤ last
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted.get_lt
|
[167, 1]
|
[177, 70]
|
induction p with
| refl => rfl
| step i j fi ij jl p ih =>
rw [ih]
rw [Vec.get_swap_neq _ i j k]
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt (Nat.lt_of_lt_of_le lt fi)
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt (Nat.lt_of_lt_of_le lt (Nat.le_trans fi ij))
|
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
p : permuted n first last arr1 arr2
k : Fin n
lt : ↑k < first
⊢ arr2[k] = arr1[k]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
p : permuted n first last arr1 arr2
k : Fin n
lt : ↑k < first
⊢ arr2[k] = arr1[k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted.get_lt
|
[167, 1]
|
[177, 70]
|
rfl
|
case refl
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ : Vec α✝ n
⊢ arr✝[k] = arr✝[k]
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case refl
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ : Vec α✝ n
⊢ arr✝[k] = arr✝[k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted.get_lt
|
[167, 1]
|
[177, 70]
|
rw [ih]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ arr'✝[k] = arr✝[k]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ (arr✝.swap i j)[k] = arr✝[k]
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ arr'✝[k] = arr✝[k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted.get_lt
|
[167, 1]
|
[177, 70]
|
rw [Vec.get_swap_neq _ i j k]
|
case step
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ (arr✝.swap i j)[k] = arr✝[k]
|
case step.ki
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ i
case step.kj
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ j
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ (arr✝.swap i j)[k] = arr✝[k]
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted.get_lt
|
[167, 1]
|
[177, 70]
|
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt (Nat.lt_of_lt_of_le lt fi)
|
case step.ki
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ i
case step.kj
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ j
|
case step.kj
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ j
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step.ki
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ i
case step.kj
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted.get_lt
|
[167, 1]
|
[177, 70]
|
. apply Fin.ne_of_val_ne
exact Nat.ne_of_lt (Nat.lt_of_lt_of_le lt (Nat.le_trans fi ij))
|
case step.kj
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ j
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step.kj
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ j
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted.get_lt
|
[167, 1]
|
[177, 70]
|
apply Fin.ne_of_val_ne
|
case step.ki
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ i
|
case step.ki.h
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ ¬↑k = ↑i
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step.ki
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ k ≠ i
TACTIC:
|
https://github.com/pandaman64/QuickSortInLean.git
|
ab0aaee0aed280959328844f9a6cd13bf00c5935
|
QuickSortInLean/Permutation.lean
|
permuted.get_lt
|
[167, 1]
|
[177, 70]
|
exact Nat.ne_of_lt (Nat.lt_of_lt_of_le lt fi)
|
case step.ki.h
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ ¬↑k = ↑i
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case step.ki.h
n first last : Nat
α✝ : Type
arr1 arr2 : Vec α✝ n
k : Fin n
lt : ↑k < first
arr✝ arr'✝ : Vec α✝ n
i j : Fin n
fi : first ≤ ↑i
ij : i ≤ j
jl : ↑j ≤ last
p : permuted n first last (arr✝.swap i j) arr'✝
ih : arr'✝[k] = (arr✝.swap i j)[k]
⊢ ¬↑k = ↑i
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.