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/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
funext x
|
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
⊢ updateITE (updateITE f a c) b d = updateITE (updateITE f b d) a c
|
case h
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
⊢ updateITE (updateITE f a c) b d x = updateITE (updateITE f b d) a c x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
⊢ updateITE (updateITE f a c) b d = updateITE (updateITE f b d) a c
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
simp only [Function.updateITE]
|
case h
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
⊢ updateITE (updateITE f a c) b d x = updateITE (updateITE f b d) a c x
|
case h
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
⊢ updateITE (updateITE f a c) b d x = updateITE (updateITE f b d) a c x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
by_cases c1 : x = a
|
case h
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : x = a
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : ¬x = a
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
by_cases c2 : x = b
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : x = a
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : x = a
c2 : x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : x = a
c2 : ¬x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : x = a
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
subst c1
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : x = a
c2 : x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 : x = b
h1 : ¬x = b
⊢ (if x = b then d else if x = x then c else f x) = if x = x then c else if x = b then d else f x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : x = a
c2 : x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
subst c2
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 : x = b
h1 : ¬x = b
⊢ (if x = b then d else if x = x then c else f x) = if x = x then c else if x = b then d else f x
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
c d : β
x : α
h1 : ¬x = x
⊢ (if x = x then d else if x = x then c else f x) = if x = x then c else if x = x then d else f x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 : x = b
h1 : ¬x = b
⊢ (if x = b then d else if x = x then c else f x) = if x = x then c else if x = b then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
contradiction
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
c d : β
x : α
h1 : ¬x = x
⊢ (if x = x then d else if x = x then c else f x) = if x = x then c else if x = x then d else f x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
c d : β
x : α
h1 : ¬x = x
⊢ (if x = x then d else if x = x then c else f x) = if x = x then c else if x = x then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
subst c1
|
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : x = a
c2 : ¬x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 h1 : ¬x = b
⊢ (if x = b then d else if x = x then c else f x) = if x = x then c else if x = b then d else f x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : x = a
c2 : ¬x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
simp
|
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 h1 : ¬x = b
⊢ (if x = b then d else if x = x then c else f x) = if x = x then c else if x = b then d else f x
|
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 h1 : ¬x = b
⊢ x = b → d = c
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 h1 : ¬x = b
⊢ (if x = b then d else if x = x then c else f x) = if x = x then c else if x = b then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
intro a1
|
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 h1 : ¬x = b
⊢ x = b → d = c
|
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 h1 : ¬x = b
a1 : x = b
⊢ d = c
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 h1 : ¬x = b
⊢ x = b → d = c
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
contradiction
|
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 h1 : ¬x = b
a1 : x = b
⊢ d = c
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
b : α
c d : β
x : α
c2 h1 : ¬x = b
a1 : x = b
⊢ d = c
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
by_cases c2 : x = b
|
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : ¬x = a
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : ¬x = a
c2 : x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : ¬x = a
c2 : ¬x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : ¬x = a
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
subst c2
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : ¬x = a
c2 : x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a : α
c d : β
x : α
c1 : ¬x = a
h1 : ¬a = x
⊢ (if x = x then d else if x = a then c else f x) = if x = a then c else if x = x then d else f x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : ¬x = a
c2 : x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
simp
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a : α
c d : β
x : α
c1 : ¬x = a
h1 : ¬a = x
⊢ (if x = x then d else if x = a then c else f x) = if x = a then c else if x = x then d else f x
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a : α
c d : β
x : α
c1 : ¬x = a
h1 : ¬a = x
⊢ d = if x = a then c else d
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a : α
c d : β
x : α
c1 : ¬x = a
h1 : ¬a = x
⊢ (if x = x then d else if x = a then c else f x) = if x = a then c else if x = x then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
simp only [if_neg c1]
|
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a : α
c d : β
x : α
c1 : ¬x = a
h1 : ¬a = x
⊢ d = if x = a then c else d
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
inst✝ : DecidableEq α
f : α → β
a : α
c d : β
x : α
c1 : ¬x = a
h1 : ¬a = x
⊢ d = if x = a then c else d
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_symm
|
[342, 1]
|
[367, 28]
|
simp only [if_neg c1]
|
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : ¬x = a
c2 : ¬x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
inst✝ : DecidableEq α
f : α → β
a b : α
c d : β
h1 : ¬a = b
x : α
c1 : ¬x = a
c2 : ¬x = b
⊢ (if x = b then d else if x = a then c else f x) = if x = a then c else if x = b then d else f x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_comp
|
[370, 1]
|
[386, 13]
|
simp only [Function.updateITE]
|
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
⊢ updateITE g c d (updateITE f b c a) = updateITE (g ∘ f) b d a
|
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
⊢ (if (if a = b then c else f a) = c then d else g (if a = b then c else f a)) = if a = b then d else (g ∘ f) a
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
⊢ updateITE g c d (updateITE f b c a) = updateITE (g ∘ f) b d a
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_comp
|
[370, 1]
|
[386, 13]
|
by_cases c1 : a = b
|
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
⊢ (if (if a = b then c else f a) = c then d else g (if a = b then c else f a)) = if a = b then d else (g ∘ f) a
|
case pos
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : a = b
⊢ (if (if a = b then c else f a) = c then d else g (if a = b then c else f a)) = if a = b then d else (g ∘ f) a
case neg
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : ¬a = b
⊢ (if (if a = b then c else f a) = c then d else g (if a = b then c else f a)) = if a = b then d else (g ∘ f) a
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
⊢ (if (if a = b then c else f a) = c then d else g (if a = b then c else f a)) = if a = b then d else (g ∘ f) a
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_comp
|
[370, 1]
|
[386, 13]
|
simp only [c1]
|
case pos
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : a = b
⊢ (if (if a = b then c else f a) = c then d else g (if a = b then c else f a)) = if a = b then d else (g ∘ f) a
|
case pos
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : a = b
⊢ (if (if True then c else f b) = c then d else g (if True then c else f b)) = if True then d else (g ∘ f) b
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : a = b
⊢ (if (if a = b then c else f a) = c then d else g (if a = b then c else f a)) = if a = b then d else (g ∘ f) a
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_comp
|
[370, 1]
|
[386, 13]
|
simp
|
case pos
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : a = b
⊢ (if (if True then c else f b) = c then d else g (if True then c else f b)) = if True then d else (g ∘ f) b
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : a = b
⊢ (if (if True then c else f b) = c then d else g (if True then c else f b)) = if True then d else (g ∘ f) b
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_comp
|
[370, 1]
|
[386, 13]
|
simp only [c1]
|
case neg
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : ¬a = b
⊢ (if (if a = b then c else f a) = c then d else g (if a = b then c else f a)) = if a = b then d else (g ∘ f) a
|
case neg
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : ¬a = b
⊢ (if (if False then c else f a) = c then d else g (if False then c else f a)) = if False then d else (g ∘ f) a
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : ¬a = b
⊢ (if (if a = b then c else f a) = c then d else g (if a = b then c else f a)) = if a = b then d else (g ∘ f) a
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_comp
|
[370, 1]
|
[386, 13]
|
simp
|
case neg
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : ¬a = b
⊢ (if (if False then c else f a) = c then d else g (if False then c else f a)) = if False then d else (g ∘ f) a
|
case neg
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : ¬a = b
⊢ f a = c → d = g (f a)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : ¬a = b
⊢ (if (if False then c else f a) = c then d else g (if False then c else f a)) = if False then d else (g ∘ f) a
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateITE_comp
|
[370, 1]
|
[386, 13]
|
exact h1
|
case neg
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : ¬a = b
⊢ f a = c → d = g (f a)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
inst✝ : DecidableEq α
a b c : α
d : β
f : α → α
g : α → β
h1 : f a = c → d = g (f a)
c1 : ¬a = b
⊢ f a = c → d = g (f a)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
induction xs generalizing ys
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs : List α
ys : List β
⊢ g ∘ updateListITE f xs ys = updateListITE (g ∘ f) xs (List.map g ys)
|
case nil
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
ys : List β
⊢ g ∘ updateListITE f [] ys = updateListITE (g ∘ f) [] (List.map g ys)
case cons
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (ys : List β), g ∘ updateListITE f tail✝ ys = updateListITE (g ∘ f) tail✝ (List.map g ys)
ys : List β
⊢ g ∘ updateListITE f (head✝ :: tail✝) ys = updateListITE (g ∘ f) (head✝ :: tail✝) (List.map g ys)
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs : List α
ys : List β
⊢ g ∘ updateListITE f xs ys = updateListITE (g ∘ f) xs (List.map g ys)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
case nil =>
simp only [Function.updateListITE]
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
ys : List β
⊢ g ∘ updateListITE f [] ys = updateListITE (g ∘ f) [] (List.map g ys)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
ys : List β
⊢ g ∘ updateListITE f [] ys = updateListITE (g ∘ f) [] (List.map g ys)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
case cons _ xs_hd xs_tl xs_ih =>
cases ys
case nil =>
simp
simp only [Function.updateListITE]
case cons ys_hd ys_tl =>
simp
simp only [Function.updateListITE]
simp only [← xs_ih]
apply Function.updateITE_comp_left
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) ys = updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g ys)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) ys = updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g ys)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
simp only [Function.updateListITE]
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
ys : List β
⊢ g ∘ updateListITE f [] ys = updateListITE (g ∘ f) [] (List.map g ys)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
ys : List β
⊢ g ∘ updateListITE f [] ys = updateListITE (g ∘ f) [] (List.map g ys)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
cases ys
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) ys = updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g ys)
|
case nil
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) [] = updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g [])
case cons
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
head✝ : β
tail✝ : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) (head✝ :: tail✝) =
updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g (head✝ :: tail✝))
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) ys = updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g ys)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
case nil =>
simp
simp only [Function.updateListITE]
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) [] = updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g [])
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) [] = updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g [])
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
case cons ys_hd ys_tl =>
simp
simp only [Function.updateListITE]
simp only [← xs_ih]
apply Function.updateITE_comp_left
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) =
updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g (ys_hd :: ys_tl))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) =
updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g (ys_hd :: ys_tl))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
simp
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) [] = updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g [])
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) [] = updateListITE (g ∘ f) (xs_hd :: xs_tl) []
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) [] = updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g [])
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
simp only [Function.updateListITE]
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) [] = updateListITE (g ∘ f) (xs_hd :: xs_tl) []
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) [] = updateListITE (g ∘ f) (xs_hd :: xs_tl) []
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
simp
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) =
updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g (ys_hd :: ys_tl))
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) =
updateListITE (g ∘ f) (xs_hd :: xs_tl) (g ys_hd :: List.map g ys_tl)
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) =
updateListITE (g ∘ f) (xs_hd :: xs_tl) (List.map g (ys_hd :: ys_tl))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
simp only [Function.updateListITE]
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) =
updateListITE (g ∘ f) (xs_hd :: xs_tl) (g ys_hd :: List.map g ys_tl)
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd =
updateITE (updateListITE (g ∘ f) xs_tl (List.map g ys_tl)) xs_hd (g ys_hd)
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) =
updateListITE (g ∘ f) (xs_hd :: xs_tl) (g ys_hd :: List.map g ys_tl)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
simp only [← xs_ih]
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd =
updateITE (updateListITE (g ∘ f) xs_tl (List.map g ys_tl)) xs_hd (g ys_hd)
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd = updateITE (g ∘ updateListITE f xs_tl ys_tl) xs_hd (g ys_hd)
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd =
updateITE (updateListITE (g ∘ f) xs_tl (List.map g ys_tl)) xs_hd (g ys_hd)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_comp
|
[391, 1]
|
[413, 41]
|
apply Function.updateITE_comp_left
|
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd = updateITE (g ∘ updateListITE f xs_tl ys_tl) xs_hd (g ys_hd)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β γ : Type
inst✝ : DecidableEq α
f : α → β
g : β → γ
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), g ∘ updateListITE f xs_tl ys = updateListITE (g ∘ f) xs_tl (List.map g ys)
ys_hd : β
ys_tl : List β
⊢ g ∘ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd = updateITE (g ∘ updateListITE f xs_tl ys_tl) xs_hd (g ys_hd)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
induction xs generalizing ys
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
xs ys : List α
x : α
h1 : f x = g x
⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map f ys) x
|
case nil
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
ys : List α
⊢ updateListITE f [] (List.map f ys) x = updateListITE g [] (List.map f ys) x
case cons
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (ys : List α), updateListITE f tail✝ (List.map f ys) x = updateListITE g tail✝ (List.map f ys) x
ys : List α
⊢ updateListITE f (head✝ :: tail✝) (List.map f ys) x = updateListITE g (head✝ :: tail✝) (List.map f ys) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
xs ys : List α
x : α
h1 : f x = g x
⊢ updateListITE f xs (List.map f ys) x = updateListITE g xs (List.map f ys) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
case nil =>
simp only [Function.updateListITE]
exact h1
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
ys : List α
⊢ updateListITE f [] (List.map f ys) x = updateListITE g [] (List.map f ys) x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
ys : List α
⊢ updateListITE f [] (List.map f ys) x = updateListITE g [] (List.map f ys) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
simp only [Function.updateListITE]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
ys : List α
⊢ updateListITE f [] (List.map f ys) x = updateListITE g [] (List.map f ys) x
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
ys : List α
⊢ f x = g x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
ys : List α
⊢ updateListITE f [] (List.map f ys) x = updateListITE g [] (List.map f ys) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
exact h1
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
ys : List α
⊢ f x = g x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
ys : List α
⊢ f x = g x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
cases ys
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys : List α
⊢ updateListITE f (xs_hd :: xs_tl) (List.map f ys) x = updateListITE g (xs_hd :: xs_tl) (List.map f ys) x
|
case nil
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ updateListITE f (xs_hd :: xs_tl) (List.map f []) x = updateListITE g (xs_hd :: xs_tl) (List.map f []) x
case cons
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
head✝ : α
tail✝ : List α
⊢ updateListITE f (xs_hd :: xs_tl) (List.map f (head✝ :: tail✝)) x =
updateListITE g (xs_hd :: xs_tl) (List.map f (head✝ :: tail✝)) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys : List α
⊢ updateListITE f (xs_hd :: xs_tl) (List.map f ys) x = updateListITE g (xs_hd :: xs_tl) (List.map f ys) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
case nil =>
simp
simp only [Function.updateListITE]
exact h1
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ updateListITE f (xs_hd :: xs_tl) (List.map f []) x = updateListITE g (xs_hd :: xs_tl) (List.map f []) x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ updateListITE f (xs_hd :: xs_tl) (List.map f []) x = updateListITE g (xs_hd :: xs_tl) (List.map f []) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
simp
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ updateListITE f (xs_hd :: xs_tl) (List.map f []) x = updateListITE g (xs_hd :: xs_tl) (List.map f []) x
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ updateListITE f (xs_hd :: xs_tl) [] x = updateListITE g (xs_hd :: xs_tl) [] x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ updateListITE f (xs_hd :: xs_tl) (List.map f []) x = updateListITE g (xs_hd :: xs_tl) (List.map f []) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
simp only [Function.updateListITE]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ updateListITE f (xs_hd :: xs_tl) [] x = updateListITE g (xs_hd :: xs_tl) [] x
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ f x = g x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ updateListITE f (xs_hd :: xs_tl) [] x = updateListITE g (xs_hd :: xs_tl) [] x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
exact h1
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ f x = g x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
⊢ f x = g x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
simp
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ updateListITE f (xs_hd :: xs_tl) (List.map f (ys_hd :: ys_tl)) x =
updateListITE g (xs_hd :: xs_tl) (List.map f (ys_hd :: ys_tl)) x
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ updateListITE f (xs_hd :: xs_tl) (f ys_hd :: List.map f ys_tl) x =
updateListITE g (xs_hd :: xs_tl) (f ys_hd :: List.map f ys_tl) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ updateListITE f (xs_hd :: xs_tl) (List.map f (ys_hd :: ys_tl)) x =
updateListITE g (xs_hd :: xs_tl) (List.map f (ys_hd :: ys_tl)) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
simp only [Function.updateListITE]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ updateListITE f (xs_hd :: xs_tl) (f ys_hd :: List.map f ys_tl) x =
updateListITE g (xs_hd :: xs_tl) (f ys_hd :: List.map f ys_tl) x
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ updateITE (updateListITE f xs_tl (List.map f ys_tl)) xs_hd (f ys_hd) x =
updateITE (updateListITE g xs_tl (List.map f ys_tl)) xs_hd (f ys_hd) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ updateListITE f (xs_hd :: xs_tl) (f ys_hd :: List.map f ys_tl) x =
updateListITE g (xs_hd :: xs_tl) (f ys_hd :: List.map f ys_tl) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
simp only [Function.updateITE]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ updateITE (updateListITE f xs_tl (List.map f ys_tl)) xs_hd (f ys_hd) x =
updateITE (updateListITE g xs_tl (List.map f ys_tl)) xs_hd (f ys_hd) x
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ (if x = xs_hd then f ys_hd else updateListITE f xs_tl (List.map f ys_tl) x) =
if x = xs_hd then f ys_hd else updateListITE g xs_tl (List.map f ys_tl) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ updateITE (updateListITE f xs_tl (List.map f ys_tl)) xs_hd (f ys_hd) x =
updateITE (updateListITE g xs_tl (List.map f ys_tl)) xs_hd (f ys_hd) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
split_ifs
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ (if x = xs_hd then f ys_hd else updateListITE f xs_tl (List.map f ys_tl) x) =
if x = xs_hd then f ys_hd else updateListITE g xs_tl (List.map f ys_tl) x
|
case pos
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
h✝ : x = xs_hd
⊢ f ys_hd = f ys_hd
case neg
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
h✝ : ¬x = xs_hd
⊢ updateListITE f xs_tl (List.map f ys_tl) x = updateListITE g xs_tl (List.map f ys_tl) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
⊢ (if x = xs_hd then f ys_hd else updateListITE f xs_tl (List.map f ys_tl) x) =
if x = xs_hd then f ys_hd else updateListITE g xs_tl (List.map f ys_tl) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
rfl
|
case pos
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
h✝ : x = xs_hd
⊢ f ys_hd = f ys_hd
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
h✝ : x = xs_hd
⊢ f ys_hd = f ys_hd
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem'
|
[416, 1]
|
[442, 26]
|
exact xs_ih ys_tl
|
case neg
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
h✝ : ¬x = xs_hd
⊢ updateListITE f xs_tl (List.map f ys_tl) x = updateListITE g xs_tl (List.map f ys_tl) x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
α β : Type
inst✝ : DecidableEq α
f g : α → β
x : α
h1 : f x = g x
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List α), updateListITE f xs_tl (List.map f ys) x = updateListITE g xs_tl (List.map f ys) x
ys_hd : α
ys_tl : List α
h✝ : ¬x = xs_hd
⊢ updateListITE f xs_tl (List.map f ys_tl) x = updateListITE g xs_tl (List.map f ys_tl) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
induction xs generalizing ys
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
xs : List α
ys : List β
h1 : v ∈ xs
h2 : xs.length = ys.length
⊢ updateListITE f xs ys v = updateListITE g xs ys v
|
case nil
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
ys : List β
h1 : v ∈ []
h2 : [].length = ys.length
⊢ updateListITE f [] ys v = updateListITE g [] ys v
case cons
α β : Type
inst✝ : DecidableEq α
f g : α → β
v head✝ : α
tail✝ : List α
tail_ih✝ :
∀ (ys : List β), v ∈ tail✝ → tail✝.length = ys.length → updateListITE f tail✝ ys v = updateListITE g tail✝ ys v
ys : List β
h1 : v ∈ head✝ :: tail✝
h2 : (head✝ :: tail✝).length = ys.length
⊢ updateListITE f (head✝ :: tail✝) ys v = updateListITE g (head✝ :: tail✝) ys v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
xs : List α
ys : List β
h1 : v ∈ xs
h2 : xs.length = ys.length
⊢ updateListITE f xs ys v = updateListITE g xs ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
case nil =>
contradiction
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
ys : List β
h1 : v ∈ []
h2 : [].length = ys.length
⊢ updateListITE f [] ys v = updateListITE g [] ys v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
ys : List β
h1 : v ∈ []
h2 : [].length = ys.length
⊢ updateListITE f [] ys v = updateListITE g [] ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
case cons xs_hd xs_tl xs_ih =>
simp at h1
cases ys
case nil =>
contradiction
case cons ys_hd ys_tl =>
simp only [Function.updateListITE]
simp only [Function.updateITE]
cases h1
case inl h1 =>
simp only [if_pos h1]
case inr h1 =>
split_ifs
case pos =>
rfl
case neg c1 =>
simp at h2
exact xs_ih ys_tl h1 h2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h1 : v ∈ xs_hd :: xs_tl
h2 : (xs_hd :: xs_tl).length = ys.length
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h1 : v ∈ xs_hd :: xs_tl
h2 : (xs_hd :: xs_tl).length = ys.length
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
contradiction
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
ys : List β
h1 : v ∈ []
h2 : [].length = ys.length
⊢ updateListITE f [] ys v = updateListITE g [] ys v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
ys : List β
h1 : v ∈ []
h2 : [].length = ys.length
⊢ updateListITE f [] ys v = updateListITE g [] ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
simp at h1
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h1 : v ∈ xs_hd :: xs_tl
h2 : (xs_hd :: xs_tl).length = ys.length
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h2 : (xs_hd :: xs_tl).length = ys.length
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h1 : v ∈ xs_hd :: xs_tl
h2 : (xs_hd :: xs_tl).length = ys.length
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
cases ys
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h2 : (xs_hd :: xs_tl).length = ys.length
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
|
case nil
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
h2 : (xs_hd :: xs_tl).length = [].length
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
case cons
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
head✝ : β
tail✝ : List β
h2 : (xs_hd :: xs_tl).length = (head✝ :: tail✝).length
⊢ updateListITE f (xs_hd :: xs_tl) (head✝ :: tail✝) v = updateListITE g (xs_hd :: xs_tl) (head✝ :: tail✝) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h2 : (xs_hd :: xs_tl).length = ys.length
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
case nil =>
contradiction
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
h2 : (xs_hd :: xs_tl).length = [].length
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
h2 : (xs_hd :: xs_tl).length = [].length
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
case cons ys_hd ys_tl =>
simp only [Function.updateListITE]
simp only [Function.updateITE]
cases h1
case inl h1 =>
simp only [if_pos h1]
case inr h1 =>
split_ifs
case pos =>
rfl
case neg c1 =>
simp at h2
exact xs_ih ys_tl h1 h2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
contradiction
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
h2 : (xs_hd :: xs_tl).length = [].length
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
h2 : (xs_hd :: xs_tl).length = [].length
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
simp only [Function.updateListITE]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
⊢ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd v = updateITE (updateListITE g xs_tl ys_tl) xs_hd ys_hd v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
simp only [Function.updateITE]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
⊢ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd v = updateITE (updateListITE g xs_tl ys_tl) xs_hd ys_hd v
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
⊢ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd v = updateITE (updateListITE g xs_tl ys_tl) xs_hd ys_hd v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
cases h1
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
|
case inl
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h✝ : v = xs_hd
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
case inr
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h✝ : v ∈ xs_tl
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
case inl h1 =>
simp only [if_pos h1]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v = xs_hd
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v = xs_hd
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
case inr h1 =>
split_ifs
case pos =>
rfl
case neg c1 =>
simp at h2
exact xs_ih ys_tl h1 h2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
simp only [if_pos h1]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v = xs_hd
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v = xs_hd
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
split_ifs
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
|
case pos
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
h✝ : v = xs_hd
⊢ ys_hd = ys_hd
case neg
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
h✝ : ¬v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
case pos =>
rfl
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
h✝ : v = xs_hd
⊢ ys_hd = ys_hd
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
h✝ : v = xs_hd
⊢ ys_hd = ys_hd
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
case neg c1 =>
simp at h2
exact xs_ih ys_tl h1 h2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
c1 : ¬v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
c1 : ¬v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
rfl
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
h✝ : v = xs_hd
⊢ ys_hd = ys_hd
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
h✝ : v = xs_hd
⊢ ys_hd = ys_hd
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
simp at h2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
c1 : ¬v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v ∈ xs_tl
c1 : ¬v = xs_hd
h2 : xs_tl.length = ys_tl.length
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h2 : (xs_hd :: xs_tl).length = (ys_hd :: ys_tl).length
h1 : v ∈ xs_tl
c1 : ¬v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem_eq_len
|
[445, 1]
|
[478, 34]
|
exact xs_ih ys_tl h1 h2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v ∈ xs_tl
c1 : ¬v = xs_hd
h2 : xs_tl.length = ys_tl.length
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → xs_tl.length = ys.length → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v ∈ xs_tl
c1 : ¬v = xs_hd
h2 : xs_tl.length = ys_tl.length
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
induction xs generalizing ys
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
xs : List α
ys : List β
h1 : v ∈ xs
h2 : f v = g v
⊢ updateListITE f xs ys v = updateListITE g xs ys v
|
case nil
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
ys : List β
h1 : v ∈ []
⊢ updateListITE f [] ys v = updateListITE g [] ys v
case cons
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (ys : List β), v ∈ tail✝ → updateListITE f tail✝ ys v = updateListITE g tail✝ ys v
ys : List β
h1 : v ∈ head✝ :: tail✝
⊢ updateListITE f (head✝ :: tail✝) ys v = updateListITE g (head✝ :: tail✝) ys v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
xs : List α
ys : List β
h1 : v ∈ xs
h2 : f v = g v
⊢ updateListITE f xs ys v = updateListITE g xs ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
case nil =>
contradiction
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
ys : List β
h1 : v ∈ []
⊢ updateListITE f [] ys v = updateListITE g [] ys v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
ys : List β
h1 : v ∈ []
⊢ updateListITE f [] ys v = updateListITE g [] ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
case cons xs_hd xs_tl xs_ih =>
cases ys
case nil =>
simp at h1
simp only [Function.updateListITE]
exact h2
case cons ys_hd ys_tl =>
simp at h1
simp only [Function.updateListITE]
simp only [Function.updateITE]
split_ifs
case pos =>
rfl
case neg c1 =>
cases h1
case inl c2 =>
contradiction
case inr c2 =>
exact xs_ih ys_tl c2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h1 : v ∈ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h1 : v ∈ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
contradiction
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
ys : List β
h1 : v ∈ []
⊢ updateListITE f [] ys v = updateListITE g [] ys v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
ys : List β
h1 : v ∈ []
⊢ updateListITE f [] ys v = updateListITE g [] ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
cases ys
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h1 : v ∈ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
|
case nil
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v ∈ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
case cons
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v ∈ xs_hd :: xs_tl
head✝ : β
tail✝ : List β
⊢ updateListITE f (xs_hd :: xs_tl) (head✝ :: tail✝) v = updateListITE g (xs_hd :: xs_tl) (head✝ :: tail✝) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys : List β
h1 : v ∈ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = updateListITE g (xs_hd :: xs_tl) ys v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
case nil =>
simp at h1
simp only [Function.updateListITE]
exact h2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v ∈ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v ∈ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
case cons ys_hd ys_tl =>
simp at h1
simp only [Function.updateListITE]
simp only [Function.updateITE]
split_ifs
case pos =>
rfl
case neg c1 =>
cases h1
case inl c2 =>
contradiction
case inr c2 =>
exact xs_ih ys_tl c2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v ∈ xs_hd :: xs_tl
ys_hd : β
ys_tl : List β
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v ∈ xs_hd :: xs_tl
ys_hd : β
ys_tl : List β
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
simp at h1
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v ∈ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v ∈ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
simp only [Function.updateListITE]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ f v = g v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = updateListITE g (xs_hd :: xs_tl) [] v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
exact h2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ f v = g v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ f v = g v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
simp at h1
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v ∈ xs_hd :: xs_tl
ys_hd : β
ys_tl : List β
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
h1 : v ∈ xs_hd :: xs_tl
ys_hd : β
ys_tl : List β
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
simp only [Function.updateListITE]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd v = updateITE (updateListITE g xs_tl ys_tl) xs_hd ys_hd v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) (ys_hd :: ys_tl) v = updateListITE g (xs_hd :: xs_tl) (ys_hd :: ys_tl) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
simp only [Function.updateITE]
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd v = updateITE (updateListITE g xs_tl ys_tl) xs_hd ys_hd v
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ updateITE (updateListITE f xs_tl ys_tl) xs_hd ys_hd v = updateITE (updateListITE g xs_tl ys_tl) xs_hd ys_hd v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
split_ifs
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
|
case pos
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
h✝ : v = xs_hd
⊢ ys_hd = ys_hd
case neg
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
h✝ : ¬v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
⊢ (if v = xs_hd then ys_hd else updateListITE f xs_tl ys_tl v) =
if v = xs_hd then ys_hd else updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
case pos =>
rfl
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
h✝ : v = xs_hd
⊢ ys_hd = ys_hd
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
h✝ : v = xs_hd
⊢ ys_hd = ys_hd
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
case neg c1 =>
cases h1
case inl c2 =>
contradiction
case inr c2 =>
exact xs_ih ys_tl c2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
c1 : ¬v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
c1 : ¬v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
rfl
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
h✝ : v = xs_hd
⊢ ys_hd = ys_hd
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
h✝ : v = xs_hd
⊢ ys_hd = ys_hd
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
cases h1
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
c1 : ¬v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
case inl
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
c1 : ¬v = xs_hd
h✝ : v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
case inr
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
c1 : ¬v = xs_hd
h✝ : v ∈ xs_tl
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
h1 : v = xs_hd ∨ v ∈ xs_tl
c1 : ¬v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
case inl c2 =>
contradiction
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
c1 : ¬v = xs_hd
c2 : v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
c1 : ¬v = xs_hd
c2 : v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
case inr c2 =>
exact xs_ih ys_tl c2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
c1 : ¬v = xs_hd
c2 : v ∈ xs_tl
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
c1 : ¬v = xs_hd
c2 : v ∈ xs_tl
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
contradiction
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
c1 : ¬v = xs_hd
c2 : v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
c1 : ¬v = xs_hd
c2 : v = xs_hd
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_mem
|
[481, 1]
|
[516, 31]
|
exact xs_ih ys_tl c2
|
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
c1 : ¬v = xs_hd
c2 : v ∈ xs_tl
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f g : α → β
v : α
h2 : f v = g v
xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∈ xs_tl → updateListITE f xs_tl ys v = updateListITE g xs_tl ys v
ys_hd : β
ys_tl : List β
c1 : ¬v = xs_hd
c2 : v ∈ xs_tl
⊢ updateListITE f xs_tl ys_tl v = updateListITE g xs_tl ys_tl v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_not_mem
|
[519, 1]
|
[548, 37]
|
induction xs generalizing ys
|
α β : Type
inst✝ : DecidableEq α
f : α → β
v : α
xs : List α
ys : List β
h1 : v ∉ xs
⊢ updateListITE f xs ys v = f v
|
case nil
α β : Type
inst✝ : DecidableEq α
f : α → β
v : α
ys : List β
h1 : v ∉ []
⊢ updateListITE f [] ys v = f v
case cons
α β : Type
inst✝ : DecidableEq α
f : α → β
v head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (ys : List β), v ∉ tail✝ → updateListITE f tail✝ ys v = f v
ys : List β
h1 : v ∉ head✝ :: tail✝
⊢ updateListITE f (head✝ :: tail✝) ys v = f v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f : α → β
v : α
xs : List α
ys : List β
h1 : v ∉ xs
⊢ updateListITE f xs ys v = f v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_not_mem
|
[519, 1]
|
[548, 37]
|
case nil =>
simp only [Function.updateListITE]
|
α β : Type
inst✝ : DecidableEq α
f : α → β
v : α
ys : List β
h1 : v ∉ []
⊢ updateListITE f [] ys v = f v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f : α → β
v : α
ys : List β
h1 : v ∉ []
⊢ updateListITE f [] ys v = f v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_not_mem
|
[519, 1]
|
[548, 37]
|
case cons xs_hd xs_tl xs_ih =>
cases ys
case nil =>
simp only [Function.updateListITE]
case cons ys_hd ys_tl =>
simp only [Function.updateListITE]
simp only [Function.updateITE]
split_ifs
case pos c1 =>
subst c1
simp at h1
case neg c1 =>
simp at h1
push_neg at h1
cases h1
case intro h1_left h1_right =>
apply xs_ih ys_tl h1_right
|
α β : Type
inst✝ : DecidableEq α
f : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∉ xs_tl → updateListITE f xs_tl ys v = f v
ys : List β
h1 : v ∉ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = f v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∉ xs_tl → updateListITE f xs_tl ys v = f v
ys : List β
h1 : v ∉ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = f v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_not_mem
|
[519, 1]
|
[548, 37]
|
simp only [Function.updateListITE]
|
α β : Type
inst✝ : DecidableEq α
f : α → β
v : α
ys : List β
h1 : v ∉ []
⊢ updateListITE f [] ys v = f v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f : α → β
v : α
ys : List β
h1 : v ∉ []
⊢ updateListITE f [] ys v = f v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_not_mem
|
[519, 1]
|
[548, 37]
|
cases ys
|
α β : Type
inst✝ : DecidableEq α
f : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∉ xs_tl → updateListITE f xs_tl ys v = f v
ys : List β
h1 : v ∉ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = f v
|
case nil
α β : Type
inst✝ : DecidableEq α
f : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∉ xs_tl → updateListITE f xs_tl ys v = f v
h1 : v ∉ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = f v
case cons
α β : Type
inst✝ : DecidableEq α
f : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∉ xs_tl → updateListITE f xs_tl ys v = f v
h1 : v ∉ xs_hd :: xs_tl
head✝ : β
tail✝ : List β
⊢ updateListITE f (xs_hd :: xs_tl) (head✝ :: tail✝) v = f v
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∉ xs_tl → updateListITE f xs_tl ys v = f v
ys : List β
h1 : v ∉ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) ys v = f v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/FunctionUpdateITE.lean
|
Function.updateListITE_not_mem
|
[519, 1]
|
[548, 37]
|
case nil =>
simp only [Function.updateListITE]
|
α β : Type
inst✝ : DecidableEq α
f : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∉ xs_tl → updateListITE f xs_tl ys v = f v
h1 : v ∉ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = f v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α β : Type
inst✝ : DecidableEq α
f : α → β
v xs_hd : α
xs_tl : List α
xs_ih : ∀ (ys : List β), v ∉ xs_tl → updateListITE f xs_tl ys v = f v
h1 : v ∉ xs_hd :: xs_tl
⊢ updateListITE f (xs_hd :: xs_tl) [] v = f v
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.