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/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
all_goals
simp only [predVarOccursIn]
simp only [Formula.predVarSet]
|
case pred_const_
P : PredName
n : β
aβΒΉ : PredName
aβ : List VarName
β’ predVarOccursIn P n (pred_const_ aβΒΉ aβ) β (P, n) β (pred_const_ aβΒΉ aβ).predVarSet
case pred_var_
P : PredName
n : β
aβΒΉ : PredName
aβ : List VarName
β’ predVarOccursIn P n (pred_var_ aβΒΉ aβ) β (P, n) β (pred_var_ aβΒΉ aβ).predVarSet
case eq_
P : PredName
n : β
aβΒΉ aβ : VarName
β’ predVarOccursIn P n (eq_ aβΒΉ aβ) β (P, n) β (eq_ aβΒΉ aβ).predVarSet
case true_
P : PredName
n : β
β’ predVarOccursIn P n true_ β (P, n) β true_.predVarSet
case false_
P : PredName
n : β
β’ predVarOccursIn P n false_ β (P, n) β false_.predVarSet
case not_
P : PredName
n : β
aβ : Formula
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n aβ.not_ β (P, n) β aβ.not_.predVarSet
case imp_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (aβΒΉ.imp_ aβ) β (P, n) β (aβΒΉ.imp_ aβ).predVarSet
case and_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (aβΒΉ.and_ aβ) β (P, n) β (aβΒΉ.and_ aβ).predVarSet
case or_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (aβΒΉ.or_ aβ) β (P, n) β (aβΒΉ.or_ aβ).predVarSet
case iff_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (aβΒΉ.iff_ aβ) β (P, n) β (aβΒΉ.iff_ aβ).predVarSet
case forall_
P : PredName
n : β
aβΒΉ : VarName
aβ : Formula
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (forall_ aβΒΉ aβ) β (P, n) β (forall_ aβΒΉ aβ).predVarSet
case exists_
P : PredName
n : β
aβΒΉ : VarName
aβ : Formula
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (exists_ aβΒΉ aβ) β (P, n) β (exists_ aβΒΉ aβ).predVarSet
case def_
P : PredName
n : β
aβΒΉ : DefName
aβ : List VarName
β’ predVarOccursIn P n (def_ aβΒΉ aβ) β (P, n) β (def_ aβΒΉ aβ).predVarSet
|
case pred_const_
P : PredName
n : β
aβΒΉ : PredName
aβ : List VarName
β’ False β (P, n) β β
case pred_var_
P : PredName
n : β
aβΒΉ : PredName
aβ : List VarName
β’ P = aβΒΉ β§ n = aβ.length β (P, n) β {(aβΒΉ, aβ.length)}
case eq_
P : PredName
n : β
aβΒΉ aβ : VarName
β’ False β (P, n) β β
case true_
P : PredName
n : β
β’ False β (P, n) β β
case false_
P : PredName
n : β
β’ False β (P, n) β β
case not_
P : PredName
n : β
aβ : Formula
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
case imp_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n aβΒΉ β¨ predVarOccursIn P n aβ β (P, n) β aβΒΉ.predVarSet βͺ aβ.predVarSet
case and_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n aβΒΉ β¨ predVarOccursIn P n aβ β (P, n) β aβΒΉ.predVarSet βͺ aβ.predVarSet
case or_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n aβΒΉ β¨ predVarOccursIn P n aβ β (P, n) β aβΒΉ.predVarSet βͺ aβ.predVarSet
case iff_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n aβΒΉ β¨ predVarOccursIn P n aβ β (P, n) β aβΒΉ.predVarSet βͺ aβ.predVarSet
case forall_
P : PredName
n : β
aβΒΉ : VarName
aβ : Formula
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
case exists_
P : PredName
n : β
aβΒΉ : VarName
aβ : Formula
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
case def_
P : PredName
n : β
aβΒΉ : DefName
aβ : List VarName
β’ False β (P, n) β β
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pred_const_
P : PredName
n : β
aβΒΉ : PredName
aβ : List VarName
β’ predVarOccursIn P n (pred_const_ aβΒΉ aβ) β (P, n) β (pred_const_ aβΒΉ aβ).predVarSet
case pred_var_
P : PredName
n : β
aβΒΉ : PredName
aβ : List VarName
β’ predVarOccursIn P n (pred_var_ aβΒΉ aβ) β (P, n) β (pred_var_ aβΒΉ aβ).predVarSet
case eq_
P : PredName
n : β
aβΒΉ aβ : VarName
β’ predVarOccursIn P n (eq_ aβΒΉ aβ) β (P, n) β (eq_ aβΒΉ aβ).predVarSet
case true_
P : PredName
n : β
β’ predVarOccursIn P n true_ β (P, n) β true_.predVarSet
case false_
P : PredName
n : β
β’ predVarOccursIn P n false_ β (P, n) β false_.predVarSet
case not_
P : PredName
n : β
aβ : Formula
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n aβ.not_ β (P, n) β aβ.not_.predVarSet
case imp_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (aβΒΉ.imp_ aβ) β (P, n) β (aβΒΉ.imp_ aβ).predVarSet
case and_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (aβΒΉ.and_ aβ) β (P, n) β (aβΒΉ.and_ aβ).predVarSet
case or_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (aβΒΉ.or_ aβ) β (P, n) β (aβΒΉ.or_ aβ).predVarSet
case iff_
P : PredName
n : β
aβΒΉ aβ : Formula
a_ihβΒΉ : predVarOccursIn P n aβΒΉ β (P, n) β aβΒΉ.predVarSet
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (aβΒΉ.iff_ aβ) β (P, n) β (aβΒΉ.iff_ aβ).predVarSet
case forall_
P : PredName
n : β
aβΒΉ : VarName
aβ : Formula
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (forall_ aβΒΉ aβ) β (P, n) β (forall_ aβΒΉ aβ).predVarSet
case exists_
P : PredName
n : β
aβΒΉ : VarName
aβ : Formula
a_ihβ : predVarOccursIn P n aβ β (P, n) β aβ.predVarSet
β’ predVarOccursIn P n (exists_ aβΒΉ aβ) β (P, n) β (exists_ aβΒΉ aβ).predVarSet
case def_
P : PredName
n : β
aβΒΉ : DefName
aβ : List VarName
β’ predVarOccursIn P n (def_ aβΒΉ aβ) β (P, n) β (def_ aβΒΉ aβ).predVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
case pred_const_ X xs | pred_var_ X xs | def_ X xs =>
simp
|
P : PredName
n : β
X : DefName
xs : List VarName
β’ False β (P, n) β β
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
X : DefName
xs : List VarName
β’ False β (P, n) β β
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
case eq_ x y =>
simp
|
P : PredName
n : β
x y : VarName
β’ False β (P, n) β β
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
x y : VarName
β’ False β (P, n) β β
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
case true_ | false_ =>
tauto
|
P : PredName
n : β
β’ False β (P, n) β β
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
β’ False β (P, n) β β
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
case not_ phi phi_ih =>
tauto
|
P : PredName
n : β
phi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
β’ predVarOccursIn P n phi β (P, n) β phi.predVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
phi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
β’ predVarOccursIn P n phi β (P, n) β phi.predVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
case
imp_ phi psi phi_ih psi_ih
| and_ phi psi phi_ih psi_ih
| or_ phi psi phi_ih psi_ih
| iff_ phi psi phi_ih psi_ih =>
simp
tauto
|
P : PredName
n : β
phi psi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
psi_ih : predVarOccursIn P n psi β (P, n) β psi.predVarSet
β’ predVarOccursIn P n phi β¨ predVarOccursIn P n psi β (P, n) β phi.predVarSet βͺ psi.predVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
phi psi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
psi_ih : predVarOccursIn P n psi β (P, n) β psi.predVarSet
β’ predVarOccursIn P n phi β¨ predVarOccursIn P n psi β (P, n) β phi.predVarSet βͺ psi.predVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
case forall_ x phi phi_ih | exists_ x phi phi_ih =>
tauto
|
P : PredName
n : β
x : VarName
phi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
β’ predVarOccursIn P n phi β (P, n) β phi.predVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
x : VarName
phi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
β’ predVarOccursIn P n phi β (P, n) β phi.predVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
simp only [predVarOccursIn]
|
case def_
P : PredName
n : β
aβΒΉ : DefName
aβ : List VarName
β’ predVarOccursIn P n (def_ aβΒΉ aβ) β (P, n) β (def_ aβΒΉ aβ).predVarSet
|
case def_
P : PredName
n : β
aβΒΉ : DefName
aβ : List VarName
β’ False β (P, n) β (def_ aβΒΉ aβ).predVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
case def_
P : PredName
n : β
aβΒΉ : DefName
aβ : List VarName
β’ predVarOccursIn P n (def_ aβΒΉ aβ) β (P, n) β (def_ aβΒΉ aβ).predVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
simp only [Formula.predVarSet]
|
case def_
P : PredName
n : β
aβΒΉ : DefName
aβ : List VarName
β’ False β (P, n) β (def_ aβΒΉ aβ).predVarSet
|
case def_
P : PredName
n : β
aβΒΉ : DefName
aβ : List VarName
β’ False β (P, n) β β
|
Please generate a tactic in lean4 to solve the state.
STATE:
case def_
P : PredName
n : β
aβΒΉ : DefName
aβ : List VarName
β’ False β (P, n) β (def_ aβΒΉ aβ).predVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
simp
|
P : PredName
n : β
X : DefName
xs : List VarName
β’ False β (P, n) β β
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
X : DefName
xs : List VarName
β’ False β (P, n) β β
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
simp
|
P : PredName
n : β
x y : VarName
β’ False β (P, n) β β
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
x y : VarName
β’ False β (P, n) β β
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
tauto
|
P : PredName
n : β
β’ False β (P, n) β β
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
β’ False β (P, n) β β
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
tauto
|
P : PredName
n : β
phi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
β’ predVarOccursIn P n phi β (P, n) β phi.predVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
phi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
β’ predVarOccursIn P n phi β (P, n) β phi.predVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
simp
|
P : PredName
n : β
phi psi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
psi_ih : predVarOccursIn P n psi β (P, n) β psi.predVarSet
β’ predVarOccursIn P n phi β¨ predVarOccursIn P n psi β (P, n) β phi.predVarSet βͺ psi.predVarSet
|
P : PredName
n : β
phi psi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
psi_ih : predVarOccursIn P n psi β (P, n) β psi.predVarSet
β’ predVarOccursIn P n phi β¨ predVarOccursIn P n psi β (P, n) β phi.predVarSet β¨ (P, n) β psi.predVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
phi psi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
psi_ih : predVarOccursIn P n psi β (P, n) β psi.predVarSet
β’ predVarOccursIn P n phi β¨ predVarOccursIn P n psi β (P, n) β phi.predVarSet βͺ psi.predVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
tauto
|
P : PredName
n : β
phi psi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
psi_ih : predVarOccursIn P n psi β (P, n) β psi.predVarSet
β’ predVarOccursIn P n phi β¨ predVarOccursIn P n psi β (P, n) β phi.predVarSet β¨ (P, n) β psi.predVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
phi psi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
psi_ih : predVarOccursIn P n psi β (P, n) β psi.predVarSet
β’ predVarOccursIn P n phi β¨ predVarOccursIn P n psi β (P, n) β phi.predVarSet β¨ (P, n) β psi.predVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.predVarOccursIn_iff_mem_predVarSet
|
[438, 1]
|
[464, 10]
|
tauto
|
P : PredName
n : β
x : VarName
phi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
β’ predVarOccursIn P n phi β (P, n) β phi.predVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
P : PredName
n : β
x : VarName
phi : Formula
phi_ih : predVarOccursIn P n phi β (P, n) β phi.predVarSet
β’ predVarOccursIn P n phi β (P, n) β phi.predVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isBoundIn_imp_occursIn
|
[467, 1]
|
[478, 10]
|
induction F
|
v : VarName
F : Formula
h1 : isBoundIn v F
β’ occursIn v F
|
case pred_const_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isBoundIn v (pred_const_ aβΒΉ aβ)
β’ occursIn v (pred_const_ aβΒΉ aβ)
case pred_var_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isBoundIn v (pred_var_ aβΒΉ aβ)
β’ occursIn v (pred_var_ aβΒΉ aβ)
case eq_
v aβΒΉ aβ : VarName
h1 : isBoundIn v (eq_ aβΒΉ aβ)
β’ occursIn v (eq_ aβΒΉ aβ)
case true_
v : VarName
h1 : isBoundIn v true_
β’ occursIn v true_
case false_
v : VarName
h1 : isBoundIn v false_
β’ occursIn v false_
case not_
v : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβ.not_
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.imp_ aβ)
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.and_ aβ)
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.or_ aβ)
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.iff_ aβ)
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (forall_ aβΒΉ aβ)
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (exists_ aβΒΉ aβ)
β’ occursIn v (exists_ aβΒΉ aβ)
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : isBoundIn v (def_ aβΒΉ aβ)
β’ occursIn v (def_ aβΒΉ aβ)
|
Please generate a tactic in lean4 to solve the state.
STATE:
v : VarName
F : Formula
h1 : isBoundIn v F
β’ occursIn v F
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isBoundIn_imp_occursIn
|
[467, 1]
|
[478, 10]
|
all_goals
simp only [isBoundIn] at h1
|
case pred_const_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isBoundIn v (pred_const_ aβΒΉ aβ)
β’ occursIn v (pred_const_ aβΒΉ aβ)
case pred_var_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isBoundIn v (pred_var_ aβΒΉ aβ)
β’ occursIn v (pred_var_ aβΒΉ aβ)
case eq_
v aβΒΉ aβ : VarName
h1 : isBoundIn v (eq_ aβΒΉ aβ)
β’ occursIn v (eq_ aβΒΉ aβ)
case true_
v : VarName
h1 : isBoundIn v true_
β’ occursIn v true_
case false_
v : VarName
h1 : isBoundIn v false_
β’ occursIn v false_
case not_
v : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβ.not_
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.imp_ aβ)
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.and_ aβ)
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.or_ aβ)
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.iff_ aβ)
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (forall_ aβΒΉ aβ)
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (exists_ aβΒΉ aβ)
β’ occursIn v (exists_ aβΒΉ aβ)
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : isBoundIn v (def_ aβΒΉ aβ)
β’ occursIn v (def_ aβΒΉ aβ)
|
case not_
v : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβ
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (exists_ aβΒΉ aβ)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pred_const_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isBoundIn v (pred_const_ aβΒΉ aβ)
β’ occursIn v (pred_const_ aβΒΉ aβ)
case pred_var_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isBoundIn v (pred_var_ aβΒΉ aβ)
β’ occursIn v (pred_var_ aβΒΉ aβ)
case eq_
v aβΒΉ aβ : VarName
h1 : isBoundIn v (eq_ aβΒΉ aβ)
β’ occursIn v (eq_ aβΒΉ aβ)
case true_
v : VarName
h1 : isBoundIn v true_
β’ occursIn v true_
case false_
v : VarName
h1 : isBoundIn v false_
β’ occursIn v false_
case not_
v : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβ.not_
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.imp_ aβ)
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.and_ aβ)
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.or_ aβ)
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (aβΒΉ.iff_ aβ)
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (forall_ aβΒΉ aβ)
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v (exists_ aβΒΉ aβ)
β’ occursIn v (exists_ aβΒΉ aβ)
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : isBoundIn v (def_ aβΒΉ aβ)
β’ occursIn v (def_ aβΒΉ aβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isBoundIn_imp_occursIn
|
[467, 1]
|
[478, 10]
|
all_goals
simp only [occursIn]
tauto
|
case not_
v : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβ
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (exists_ aβΒΉ aβ)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case not_
v : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβ
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isBoundIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : isBoundIn v aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (exists_ aβΒΉ aβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isBoundIn_imp_occursIn
|
[467, 1]
|
[478, 10]
|
simp only [isBoundIn] at h1
|
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : isBoundIn v (def_ aβΒΉ aβ)
β’ occursIn v (def_ aβΒΉ aβ)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : isBoundIn v (def_ aβΒΉ aβ)
β’ occursIn v (def_ aβΒΉ aβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isBoundIn_imp_occursIn
|
[467, 1]
|
[478, 10]
|
simp only [occursIn]
|
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (exists_ aβΒΉ aβ)
|
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ v = aβΒΉ β¨ occursIn v aβ
|
Please generate a tactic in lean4 to solve the state.
STATE:
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ occursIn v (exists_ aβΒΉ aβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isBoundIn_imp_occursIn
|
[467, 1]
|
[478, 10]
|
tauto
|
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ v = aβΒΉ β¨ occursIn v aβ
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isBoundIn v aβ β occursIn v aβ
h1 : v = aβΒΉ β¨ isBoundIn v aβ
β’ v = aβΒΉ β¨ occursIn v aβ
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isFreeIn_imp_occursIn
|
[481, 1]
|
[492, 10]
|
induction F
|
v : VarName
F : Formula
h1 : isFreeIn v F
β’ occursIn v F
|
case pred_const_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isFreeIn v (pred_const_ aβΒΉ aβ)
β’ occursIn v (pred_const_ aβΒΉ aβ)
case pred_var_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isFreeIn v (pred_var_ aβΒΉ aβ)
β’ occursIn v (pred_var_ aβΒΉ aβ)
case eq_
v aβΒΉ aβ : VarName
h1 : isFreeIn v (eq_ aβΒΉ aβ)
β’ occursIn v (eq_ aβΒΉ aβ)
case true_
v : VarName
h1 : isFreeIn v true_
β’ occursIn v true_
case false_
v : VarName
h1 : isFreeIn v false_
β’ occursIn v false_
case not_
v : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβ.not_
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.imp_ aβ)
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.and_ aβ)
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.or_ aβ)
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.iff_ aβ)
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (forall_ aβΒΉ aβ)
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (exists_ aβΒΉ aβ)
β’ occursIn v (exists_ aβΒΉ aβ)
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : isFreeIn v (def_ aβΒΉ aβ)
β’ occursIn v (def_ aβΒΉ aβ)
|
Please generate a tactic in lean4 to solve the state.
STATE:
v : VarName
F : Formula
h1 : isFreeIn v F
β’ occursIn v F
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isFreeIn_imp_occursIn
|
[481, 1]
|
[492, 10]
|
all_goals
simp only [isFreeIn] at h1
|
case pred_const_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isFreeIn v (pred_const_ aβΒΉ aβ)
β’ occursIn v (pred_const_ aβΒΉ aβ)
case pred_var_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isFreeIn v (pred_var_ aβΒΉ aβ)
β’ occursIn v (pred_var_ aβΒΉ aβ)
case eq_
v aβΒΉ aβ : VarName
h1 : isFreeIn v (eq_ aβΒΉ aβ)
β’ occursIn v (eq_ aβΒΉ aβ)
case true_
v : VarName
h1 : isFreeIn v true_
β’ occursIn v true_
case false_
v : VarName
h1 : isFreeIn v false_
β’ occursIn v false_
case not_
v : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβ.not_
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.imp_ aβ)
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.and_ aβ)
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.or_ aβ)
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.iff_ aβ)
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (forall_ aβΒΉ aβ)
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (exists_ aβΒΉ aβ)
β’ occursIn v (exists_ aβΒΉ aβ)
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : isFreeIn v (def_ aβΒΉ aβ)
β’ occursIn v (def_ aβΒΉ aβ)
|
case pred_const_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (pred_const_ aβΒΉ aβ)
case pred_var_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (pred_var_ aβΒΉ aβ)
case eq_
v aβΒΉ aβ : VarName
h1 : v = aβΒΉ β¨ v = aβ
β’ occursIn v (eq_ aβΒΉ aβ)
case not_
v : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβ
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : Β¬v = aβΒΉ β§ isFreeIn v aβ
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : Β¬v = aβΒΉ β§ isFreeIn v aβ
β’ occursIn v (exists_ aβΒΉ aβ)
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (def_ aβΒΉ aβ)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pred_const_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isFreeIn v (pred_const_ aβΒΉ aβ)
β’ occursIn v (pred_const_ aβΒΉ aβ)
case pred_var_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : isFreeIn v (pred_var_ aβΒΉ aβ)
β’ occursIn v (pred_var_ aβΒΉ aβ)
case eq_
v aβΒΉ aβ : VarName
h1 : isFreeIn v (eq_ aβΒΉ aβ)
β’ occursIn v (eq_ aβΒΉ aβ)
case true_
v : VarName
h1 : isFreeIn v true_
β’ occursIn v true_
case false_
v : VarName
h1 : isFreeIn v false_
β’ occursIn v false_
case not_
v : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβ.not_
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.imp_ aβ)
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.and_ aβ)
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.or_ aβ)
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (aβΒΉ.iff_ aβ)
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (forall_ aβΒΉ aβ)
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v (exists_ aβΒΉ aβ)
β’ occursIn v (exists_ aβΒΉ aβ)
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : isFreeIn v (def_ aβΒΉ aβ)
β’ occursIn v (def_ aβΒΉ aβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isFreeIn_imp_occursIn
|
[481, 1]
|
[492, 10]
|
all_goals
simp only [occursIn]
tauto
|
case pred_const_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (pred_const_ aβΒΉ aβ)
case pred_var_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (pred_var_ aβΒΉ aβ)
case eq_
v aβΒΉ aβ : VarName
h1 : v = aβΒΉ β¨ v = aβ
β’ occursIn v (eq_ aβΒΉ aβ)
case not_
v : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβ
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : Β¬v = aβΒΉ β§ isFreeIn v aβ
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : Β¬v = aβΒΉ β§ isFreeIn v aβ
β’ occursIn v (exists_ aβΒΉ aβ)
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (def_ aβΒΉ aβ)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pred_const_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (pred_const_ aβΒΉ aβ)
case pred_var_
v : VarName
aβΒΉ : PredName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (pred_var_ aβΒΉ aβ)
case eq_
v aβΒΉ aβ : VarName
h1 : v = aβΒΉ β¨ v = aβ
β’ occursIn v (eq_ aβΒΉ aβ)
case not_
v : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβ
β’ occursIn v aβ.not_
case imp_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.imp_ aβ)
case and_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.and_ aβ)
case or_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.or_ aβ)
case iff_
v : VarName
aβΒΉ aβ : Formula
a_ihβΒΉ : isFreeIn v aβΒΉ β occursIn v aβΒΉ
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : isFreeIn v aβΒΉ β¨ isFreeIn v aβ
β’ occursIn v (aβΒΉ.iff_ aβ)
case forall_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : Β¬v = aβΒΉ β§ isFreeIn v aβ
β’ occursIn v (forall_ aβΒΉ aβ)
case exists_
v aβΒΉ : VarName
aβ : Formula
a_ihβ : isFreeIn v aβ β occursIn v aβ
h1 : Β¬v = aβΒΉ β§ isFreeIn v aβ
β’ occursIn v (exists_ aβΒΉ aβ)
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (def_ aβΒΉ aβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isFreeIn_imp_occursIn
|
[481, 1]
|
[492, 10]
|
simp only [isFreeIn] at h1
|
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : isFreeIn v (def_ aβΒΉ aβ)
β’ occursIn v (def_ aβΒΉ aβ)
|
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (def_ aβΒΉ aβ)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : isFreeIn v (def_ aβΒΉ aβ)
β’ occursIn v (def_ aβΒΉ aβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isFreeIn_imp_occursIn
|
[481, 1]
|
[492, 10]
|
simp only [occursIn]
|
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (def_ aβΒΉ aβ)
|
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : v β aβ
β’ v β aβ
|
Please generate a tactic in lean4 to solve the state.
STATE:
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : v β aβ
β’ occursIn v (def_ aβΒΉ aβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Binders.lean
|
FOL.NV.isFreeIn_imp_occursIn
|
[481, 1]
|
[492, 10]
|
tauto
|
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : v β aβ
β’ v β aβ
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case def_
v : VarName
aβΒΉ : DefName
aβ : List VarName
h1 : v β aβ
β’ v β aβ
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
induction F generalizing binders V
|
D : Type
I : Interpretation D
V V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
binders : Finset VarName
F : Formula
h1 : admitsAux Ο binders F
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E F β
Holds D I V E (replace Ο F)
|
case pred_const_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβΒΉ : PredName
aβ : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_const_ aβΒΉ aβ)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_const_ aβΒΉ aβ) β
Holds D I V E (replace Ο (pred_const_ aβΒΉ aβ))
case pred_var_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβΒΉ : PredName
aβ : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_var_ aβΒΉ aβ)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ aβΒΉ aβ) β
Holds D I V E (replace Ο (pred_var_ aβΒΉ aβ))
case eq_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβΒΉ aβ : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ aβΒΉ aβ)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (eq_ aβΒΉ aβ) β
Holds D I V E (replace Ο (eq_ aβΒΉ aβ))
case true_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders true_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E true_ β
Holds D I V E (replace Ο true_)
case false_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E false_ β
Holds D I V E (replace Ο false_)
case not_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβ : Formula
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβ β
Holds D I V E (replace Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders aβ.not_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβ.not_ β
Holds D I V E (replace Ο aβ.not_)
case imp_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβΒΉ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβΒΉ β
Holds D I V E (replace Ο aβΒΉ))
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβ β
Holds D I V E (replace Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (aβΒΉ.imp_ aβ)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (aβΒΉ.imp_ aβ) β
Holds D I V E (replace Ο (aβΒΉ.imp_ aβ))
case and_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβΒΉ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβΒΉ β
Holds D I V E (replace Ο aβΒΉ))
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβ β
Holds D I V E (replace Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (aβΒΉ.and_ aβ)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (aβΒΉ.and_ aβ) β
Holds D I V E (replace Ο (aβΒΉ.and_ aβ))
case or_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβΒΉ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβΒΉ β
Holds D I V E (replace Ο aβΒΉ))
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβ β
Holds D I V E (replace Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (aβΒΉ.or_ aβ)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (aβΒΉ.or_ aβ) β
Holds D I V E (replace Ο (aβΒΉ.or_ aβ))
case iff_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβΒΉ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβΒΉ β
Holds D I V E (replace Ο aβΒΉ))
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβ β
Holds D I V E (replace Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (aβΒΉ.iff_ aβ)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (aβΒΉ.iff_ aβ) β
Holds D I V E (replace Ο (aβΒΉ.iff_ aβ))
case forall_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβΒΉ : VarName
aβ : Formula
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβ β
Holds D I V E (replace Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (forall_ aβΒΉ aβ)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (forall_ aβΒΉ aβ) β
Holds D I V E (replace Ο (forall_ aβΒΉ aβ))
case exists_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβΒΉ : VarName
aβ : Formula
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E aβ β
Holds D I V E (replace Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (exists_ aβΒΉ aβ)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ aβΒΉ aβ) β
Holds D I V E (replace Ο (exists_ aβΒΉ aβ))
case def_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
aβΒΉ : DefName
aβ : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ aβΒΉ aβ)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (def_ aβΒΉ aβ) β
Holds D I V E (replace Ο (def_ aβΒΉ aβ))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
binders : Finset VarName
F : Formula
h1 : admitsAux Ο binders F
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E F β
Holds D I V E (replace Ο F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
case pred_const_ X xs =>
simp only [replace]
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_const_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_const_ X xs) β
Holds D I V E (replace Ο (pred_const_ X xs))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_const_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_const_ X xs) β
Holds D I V E (replace Ο (pred_const_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
case eq_ x y =>
simp only [replace]
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (replace Ο (eq_ x y))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (replace Ο (eq_ x y))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
case true_ | false_ =>
simp only [replace]
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E false_ β
Holds D I V E (replace Ο false_)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E false_ β
Holds D I V E (replace Ο false_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
case not_ phi phi_ih =>
simp only [admitsAux] at h1
simp only [replace]
simp only [Holds]
congr! 1
exact phi_ih V binders h1 h2
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi.not_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace Ο phi.not_)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi.not_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace Ο phi.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
case forall_ x phi phi_ih | exists_ x phi phi_ih =>
simp only [admitsAux] at h1
simp only [replace]
simp only [Holds]
first | apply forall_congr' | apply exists_congr
intro d
apply phi_ih (Function.updateITE V x d) (binders βͺ {x}) h1
intro v a1
simp only [Function.updateITE]
simp at a1
push_neg at a1
cases a1
case h.intro a1_left a1_right =>
simp only [if_neg a1_right]
exact h2 v a1_left
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (exists_ x phi)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace Ο (exists_ x phi))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (exists_ x phi)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace Ο (exists_ x phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_const_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_const_ X xs) β
Holds D I V E (replace Ο (pred_const_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_const_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_const_ X xs) β
Holds D I V E (pred_const_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_const_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_const_ X xs) β
Holds D I V E (replace Ο (pred_const_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_const_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_const_ X xs) β
Holds D I V E (pred_const_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_const_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_const_ X xs) β
Holds D I V E (pred_const_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [admitsAux] at h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_var_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 :
Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2 β§
(β x β binders, Β¬(isFreeIn x (Ο X xs.length).2 β§ x β (Ο X xs.length).1)) β§ xs.length = (Ο X xs.length).1.length
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_var_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp at h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 :
Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2 β§
(β x β binders, Β¬(isFreeIn x (Ο X xs.length).2 β§ x β (Ο X xs.length).1)) β§ xs.length = (Ο X xs.length).1.length
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1 :
Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2 β§
(β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1) β§ xs.length = (Ο X xs.length).1.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 :
Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2 β§
(β x β binders, Β¬(isFreeIn x (Ο X xs.length).2 β§ x β (Ο X xs.length).1)) β§ xs.length = (Ο X xs.length).1.length
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
cases h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1 :
Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2 β§
(β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1) β§ xs.length = (Ο X xs.length).1.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
case intro
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
leftβ : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
rightβ : (β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1) β§ xs.length = (Ο X xs.length).1.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1 :
Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2 β§
(β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1) β§ xs.length = (Ο X xs.length).1.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
cases h1_right
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right : (β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1) β§ xs.length = (Ο X xs.length).1.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
case intro
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
leftβ : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
rightβ : xs.length = (Ο X xs.length).1.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right : (β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1) β§ xs.length = (Ο X xs.length).1.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
obtain s1 :=
Sub.Var.All.Rec.substitution_theorem D I V E (Function.updateListITE id (Ο X xs.length).fst xs)
(Ο X xs.length).snd h1_left
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (V β Function.updateListITE id (Ο X xs.length).1 xs) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [Function.updateListITE_comp] at s1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (V β Function.updateListITE id (Ο X xs.length).1 xs) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE (V β id) (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (V β Function.updateListITE id (Ο X xs.length).1 xs) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp at s1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE (V β id) (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE (V β id) (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [s2] at s1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
s2 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s2 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
s2 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
clear s2
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s2 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s2 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ (if (List.map V xs).length = (Ο X (List.map V xs).length).1.length then
Holds D I (Function.updateListITE V' (Ο X (List.map V xs).length).1 (List.map V xs)) E
(Ο X (List.map V xs).length).2
else I.pred_var_ X (List.map V xs)) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (pred_var_ X xs) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ (if (List.map V xs).length = (Ο X (List.map V xs).length).1.length then
Holds D I (Function.updateListITE V' (Ο X (List.map V xs).length).1 (List.map V xs)) E
(Ο X (List.map V xs).length).2
else I.pred_var_ X (List.map V xs)) β
Holds D I V E (replace Ο (pred_var_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ (if (List.map V xs).length = (Ο X (List.map V xs).length).1.length then
Holds D I (Function.updateListITE V' (Ο X (List.map V xs).length).1 (List.map V xs)) E
(Ο X (List.map V xs).length).2
else I.pred_var_ X (List.map V xs)) β
Holds D I V E
(if xs.length = (Ο X xs.length).1.length then
Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
else pred_var_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ (if (List.map V xs).length = (Ο X (List.map V xs).length).1.length then
Holds D I (Function.updateListITE V' (Ο X (List.map V xs).length).1 (List.map V xs)) E
(Ο X (List.map V xs).length).2
else I.pred_var_ X (List.map V xs)) β
Holds D I V E (replace Ο (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ (if (List.map V xs).length = (Ο X (List.map V xs).length).1.length then
Holds D I (Function.updateListITE V' (Ο X (List.map V xs).length).1 (List.map V xs)) E
(Ο X (List.map V xs).length).2
else I.pred_var_ X (List.map V xs)) β
Holds D I V E
(if xs.length = (Ο X xs.length).1.length then
Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
else pred_var_ X xs)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ (if xs.length = (Ο X xs.length).1.length then
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2
else I.pred_var_ X (List.map V xs)) β
Holds D I V E
(if xs.length = (Ο X xs.length).1.length then
Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
else pred_var_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ (if (List.map V xs).length = (Ο X (List.map V xs).length).1.length then
Holds D I (Function.updateListITE V' (Ο X (List.map V xs).length).1 (List.map V xs)) E
(Ο X (List.map V xs).length).2
else I.pred_var_ X (List.map V xs)) β
Holds D I V E
(if xs.length = (Ο X xs.length).1.length then
Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
else pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [if_pos h1_right_right]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ (if xs.length = (Ο X xs.length).1.length then
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2
else I.pred_var_ X (List.map V xs)) β
Holds D I V E
(if xs.length = (Ο X xs.length).1.length then
Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
else pred_var_ X xs)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ (if xs.length = (Ο X xs.length).1.length then
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2
else I.pred_var_ X (List.map V xs)) β
Holds D I V E
(if xs.length = (Ο X xs.length).1.length then
Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
else pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
exact s1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
apply Holds_coincide_Var
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ β (v : VarName),
isFreeIn v (Ο X xs.length).2 β
Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I (Function.updateListITE V' (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
intro v a1
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ β (v : VarName),
isFreeIn v (Ο X xs.length).2 β
Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
β’ β (v : VarName),
isFreeIn v (Ο X xs.length).2 β
Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
by_cases c1 : v β (Ο X xs.length).fst
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
apply Function.updateListITE_mem_eq_len V V' v (Ο X xs.length).fst (List.map V xs) c1
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ (Ο X xs.length).1.length = (List.map V xs).length
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ (Ο X xs.length).1.length = (List.map V xs).length
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ (Ο X xs.length).1.length = xs.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ (Ο X xs.length).1.length = (List.map V xs).length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
symm
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ (Ο X xs.length).1.length = xs.length
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ xs.length = (Ο X xs.length).1.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ (Ο X xs.length).1.length = xs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
exact h1_right_right
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ xs.length = (Ο X xs.length).1.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ xs.length = (Ο X xs.length).1.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
by_cases c2 : v β binders
|
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
specialize h1_right_left v c2 a1
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
h1_right_left : v β (Ο X xs.length).1
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
contradiction
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
h1_right_left : v β (Ο X xs.length).1
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
h1_right_left : v β (Ο X xs.length).1
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
specialize h2 v c2
|
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
h2 : V v = V' v
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
apply Function.updateListITE_mem'
|
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
h2 : V v = V' v
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
|
case neg.h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
h2 : V v = V' v
β’ V v = V' v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
h2 : V v = V' v
β’ Function.updateListITE V (Ο X xs.length).1 (List.map V xs) v =
Function.updateListITE V' (Ο X xs.length).1 (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
exact h2
|
case neg.h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
h2 : V v = V' v
β’ V v = V' v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1_left : Var.All.Rec.admits (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2
h1_right_left : β x β binders, isFreeIn x (Ο X xs.length).2 β x β (Ο X xs.length).1
h1_right_right : xs.length = (Ο X xs.length).1.length
s1 :
Holds D I (Function.updateListITE V (Ο X xs.length).1 (List.map V xs)) E (Ο X xs.length).2 β
Holds D I V E (Var.All.Rec.fastReplaceFree (Function.updateListITE id (Ο X xs.length).1 xs) (Ο X xs.length).2)
v : VarName
a1 : isFreeIn v (Ο X xs.length).2
c1 : v β (Ο X xs.length).1
c2 : v β binders
h2 : V v = V' v
β’ V v = V' v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (replace Ο (eq_ x y))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (eq_ x y)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (replace Ο (eq_ x y))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (eq_ x y)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (eq_ x y)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E false_ β
Holds D I V E (replace Ο false_)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E false_ β
Holds D I V E false_
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E false_ β
Holds D I V E (replace Ο false_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E false_ β
Holds D I V E false_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E false_ β
Holds D I V E false_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [admitsAux] at h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi.not_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace Ο phi.not_)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace Ο phi.not_)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi.not_
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace Ο phi.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace Ο phi.not_)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace Ο phi).not_
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace Ο phi.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace Ο phi).not_
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Β¬Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Β¬Holds D I V E (replace Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace Ο phi).not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
congr! 1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Β¬Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Β¬Holds D I V E (replace Ο phi)
|
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Β¬Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Β¬Holds D I V E (replace Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
exact phi_ih V binders h1 h2
|
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [admitsAux] at h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (phi.iff_ psi)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E (replace Ο (phi.iff_ psi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E (replace Ο (phi.iff_ psi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (phi.iff_ psi)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E (replace Ο (phi.iff_ psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E (replace Ο (phi.iff_ psi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E ((replace Ο phi).iff_ (replace Ο psi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E (replace Ο (phi.iff_ psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E ((replace Ο phi).iff_ (replace Ο psi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V x = V' x
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace Ο phi) β Holds D I V E (replace Ο psi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E ((replace Ο phi).iff_ (replace Ο psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
cases h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V x = V' x
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace Ο phi) β Holds D I V E (replace Ο psi))
|
case intro
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
leftβ : admitsAux Ο binders phi
rightβ : admitsAux Ο binders psi
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace Ο phi) β Holds D I V E (replace Ο psi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V x = V' x
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace Ο phi) β Holds D I V E (replace Ο psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
congr! 1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace Ο phi) β Holds D I V E (replace Ο psi))
|
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi)
case a.h.e'_2.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace Ο phi) β Holds D I V E (replace Ο psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
exact phi_ih V binders h1_left h2
|
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
exact psi_ih V binders h1_right h2
|
case a.h.e'_2.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_2.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V x = V' x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace Ο psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [admitsAux] at h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (exists_ x phi)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace Ο (exists_ x phi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace Ο (exists_ x phi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (exists_ x phi)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace Ο (exists_ x phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace Ο (exists_ x phi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (exists_ x (replace Ο phi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace Ο (exists_ x phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (exists_ x (replace Ο phi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ (β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β d, Holds D I (Function.updateITE V x d) E (replace Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (exists_ x (replace Ο phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
first | apply forall_congr' | apply exists_congr
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ (β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β d, Holds D I (Function.updateITE V x d) E (replace Ο phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ β (a : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x a) E phi β
Holds D I (Function.updateITE V x a) E (replace Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ (β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β d, Holds D I (Function.updateITE V x d) E (replace Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
intro d
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ β (a : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x a) E phi β
Holds D I (Function.updateITE V x a) E (replace Ο phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi β
Holds D I (Function.updateITE V x d) E (replace Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ β (a : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x a) E phi β
Holds D I (Function.updateITE V x a) E (replace Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
apply phi_ih (Function.updateITE V x d) (binders βͺ {x}) h1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi β
Holds D I (Function.updateITE V x d) E (replace Ο phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
β’ β x_1 β binders βͺ {x}, Function.updateITE V x d x_1 = V' x_1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi β
Holds D I (Function.updateITE V x d) E (replace Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
intro v a1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
β’ β x_1 β binders βͺ {x}, Function.updateITE V x d x_1 = V' x_1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ Function.updateITE V x d v = V' v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
β’ β x_1 β binders βͺ {x}, Function.updateITE V x d x_1 = V' x_1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [Function.updateITE]
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ Function.updateITE V x d v = V' v
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ (if v = x then d else V v) = V' v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ Function.updateITE V x d v = V' v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp at a1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ (if v = x then d else V v) = V' v
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders β§ Β¬v = x
β’ (if v = x then d else V v) = V' v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ (if v = x then d else V v) = V' v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
push_neg at a1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders β§ Β¬v = x
β’ (if v = x then d else V v) = V' v
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders β§ v β x
β’ (if v = x then d else V v) = V' v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders β§ Β¬v = x
β’ (if v = x then d else V v) = V' v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
cases a1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders β§ v β x
β’ (if v = x then d else V v) = V' v
|
case h.intro
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
leftβ : v β binders
rightβ : v β x
β’ (if v = x then d else V v) = V' v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1 : v β binders β§ v β x
β’ (if v = x then d else V v) = V' v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
case h.intro a1_left a1_right =>
simp only [if_neg a1_right]
exact h2 v a1_left
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ (if v = x then d else V v) = V' v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ (if v = x then d else V v) = V' v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
apply forall_congr'
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ (β (d : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β (d : D), Holds D I (Function.updateITE V x d) E (replace Ο phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ β (a : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x a) E phi β
Holds D I (Function.updateITE V x a) E (replace Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ (β (d : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β (d : D), Holds D I (Function.updateITE V x d) E (replace Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
apply exists_congr
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ (β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β d, Holds D I (Function.updateITE V x d) E (replace Ο phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ β (a : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x a) E phi β
Holds D I (Function.updateITE V x a) E (replace Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
β’ (β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β d, Holds D I (Function.updateITE V x d) E (replace Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [if_neg a1_right]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ (if v = x then d else V v) = V' v
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ V v = V' v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ (if v = x then d else V v) = V' v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
exact h2 v a1_left
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ V v = V' v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V x = V' x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V x = V' x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ V v = V' v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
cases E
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (def_ X xs) β
Holds D I V E (replace Ο (def_ X xs))
|
case nil
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) [] (Ο X ds.length).2
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (replace Ο (def_ X xs))
case cons
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
headβ : Definition
tailβ : List Definition
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) (headβ :: tailβ) (Ο X ds.length).2
else I.pred_var_ X ds }
V (headβ :: tailβ) (def_ X xs) β
Holds D I V (headβ :: tailβ) (replace Ο (def_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) E (Ο X ds.length).2
else I.pred_var_ X ds }
V E (def_ X xs) β
Holds D I V E (replace Ο (def_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
case nil =>
simp only [replace]
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) [] (Ο X ds.length).2
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (replace Ο (def_ X xs))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) [] (Ο X ds.length).2
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (replace Ο (def_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) [] (Ο X ds.length).2
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (replace Ο (def_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) [] (Ο X ds.length).2
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) [] (Ο X ds.length).2
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (replace Ο (def_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) [] (Ο X ds.length).2
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) [] (Ο X ds.length).2
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.substitution_theorem_aux
|
[109, 1]
|
[238, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
hd : Definition
tl : List Definition
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) (hd :: tl) (Ο X ds.length).2
else I.pred_var_ X ds }
V (hd :: tl) (def_ X xs) β
Holds D I V (hd :: tl) (replace Ο (def_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
hd : Definition
tl : List Definition
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) (hd :: tl) (Ο X ds.length).2
else I.pred_var_ X ds }
V (hd :: tl) (def_ X xs) β
Holds D I V (hd :: tl) (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
Ο : PredName β β β List VarName Γ Formula
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V x = V' x
hd : Definition
tl : List Definition
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if ds.length = (Ο X ds.length).1.length then
Holds D I (Function.updateListITE V' (Ο X ds.length).1 ds) (hd :: tl) (Ο X ds.length).2
else I.pred_var_ X ds }
V (hd :: tl) (def_ X xs) β
Holds D I V (hd :: tl) (replace Ο (def_ X xs))
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.