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/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
apply PrefixAppend
|
case star_repetition
V_N V_T : Type
R : V_N β PE V_N V_T
eβ : PE V_N V_T
xs_1β xs_2β ysβ : List V_T
n1β n2β : β
aβΒΉ : Interpretation V_N V_T R (eβ, xs_1β ++ xs_2β ++ ysβ) (n1β, some xs_1β)
aβ : Interpretation V_N V_T R (eβ.star, xs_2β ++ ysβ) (n2β, some xs_2β)
ih :
β m < n1β + n2β + 1,
β (e : PE V_N V_T),
Interpretation V_N V_T R (e, xs_1β ++ xs_2β ++ ysβ) (m, some (xs_1β ++ xs_2β)) β
(xs_1β ++ xs_2β).IsPrefix (xs_1β ++ xs_2β ++ ysβ)
β’ (xs_1β ++ xs_2β).IsPrefix (xs_1β ++ xs_2β ++ ysβ)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case star_repetition
V_N V_T : Type
R : V_N β PE V_N V_T
eβ : PE V_N V_T
xs_1β xs_2β ysβ : List V_T
n1β n2β : β
aβΒΉ : Interpretation V_N V_T R (eβ, xs_1β ++ xs_2β ++ ysβ) (n1β, some xs_1β)
aβ : Interpretation V_N V_T R (eβ.star, xs_2β ++ ysβ) (n2β, some xs_2β)
ih :
β m < n1β + n2β + 1,
β (e : PE V_N V_T),
Interpretation V_N V_T R (e, xs_1β ++ xs_2β ++ ysβ) (m, some (xs_1β ++ xs_2β)) β
(xs_1β ++ xs_2β).IsPrefix (xs_1β ++ xs_2β ++ ysβ)
β’ (xs_1β ++ xs_2β).IsPrefix (xs_1β ++ xs_2β ++ ysβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
specialize ih n _ (R A)
|
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
A : V_N
n : β
ih : β m < n + 1, β (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) β ys.IsPrefix xs
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
β’ ys.IsPrefix xs
|
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
A : V_N
n : β
ih : β m < n + 1, β (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) β ys.IsPrefix xs
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
β’ n < n + 1
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
A : V_N
n : β
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
ih : Interpretation V_N V_T R (R A, xs) (n, some ys) β ys.IsPrefix xs
β’ ys.IsPrefix xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
A : V_N
n : β
ih : β m < n + 1, β (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) β ys.IsPrefix xs
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
β’ ys.IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
omega
|
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
A : V_N
n : β
ih : β m < n + 1, β (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) β ys.IsPrefix xs
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
β’ n < n + 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
A : V_N
n : β
ih : β m < n + 1, β (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) β ys.IsPrefix xs
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
β’ n < n + 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
exact ih ih_1
|
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
A : V_N
n : β
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
ih : Interpretation V_N V_T R (R A, xs) (n, some ys) β ys.IsPrefix xs
β’ ys.IsPrefix xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
A : V_N
n : β
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
ih : Interpretation V_N V_T R (R A, xs) (n, some ys) β ys.IsPrefix xs
β’ ys.IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
specialize ih n2 _ e2
|
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : β
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih : β m < n1 + n2 + 1, β (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) β ys.IsPrefix xs
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
β’ ys.IsPrefix xs
|
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : β
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih : β m < n1 + n2 + 1, β (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) β ys.IsPrefix xs
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
β’ n2 < n1 + n2 + 1
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : β
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
ih : Interpretation V_N V_T R (e2, xs) (n2, some ys) β ys.IsPrefix xs
β’ ys.IsPrefix xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : β
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih : β m < n1 + n2 + 1, β (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) β ys.IsPrefix xs
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
β’ ys.IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
omega
|
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : β
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih : β m < n1 + n2 + 1, β (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) β ys.IsPrefix xs
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
β’ n2 < n1 + n2 + 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : β
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih : β m < n1 + n2 + 1, β (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) β ys.IsPrefix xs
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
β’ n2 < n1 + n2 + 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
exact ih ih_2
|
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : β
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
ih : Interpretation V_N V_T R (e2, xs) (n2, some ys) β ys.IsPrefix xs
β’ ys.IsPrefix xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N β PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : β
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
ih : Interpretation V_N V_T R (e2, xs) (n2, some ys) β ys.IsPrefix xs
β’ ys.IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
induction F
|
F : Formula
Ο : PredName β PredName
h1 : F.predVarSet = β
β’ sub Ο F = F
|
case pred_const_
Ο : PredName β PredName
aβΒΉ : PredName
aβ : List VarName
h1 : (pred_const_ aβΒΉ aβ).predVarSet = β
β’ sub Ο (pred_const_ aβΒΉ aβ) = pred_const_ aβΒΉ aβ
case pred_var_
Ο : PredName β PredName
aβΒΉ : PredName
aβ : List VarName
h1 : (pred_var_ aβΒΉ aβ).predVarSet = β
β’ sub Ο (pred_var_ aβΒΉ aβ) = pred_var_ aβΒΉ aβ
case eq_
Ο : PredName β PredName
aβΒΉ aβ : VarName
h1 : (eq_ aβΒΉ aβ).predVarSet = β
β’ sub Ο (eq_ aβΒΉ aβ) = eq_ aβΒΉ aβ
case true_
Ο : PredName β PredName
h1 : true_.predVarSet = β
β’ sub Ο true_ = true_
case false_
Ο : PredName β PredName
h1 : false_.predVarSet = β
β’ sub Ο false_ = false_
case not_
Ο : PredName β PredName
aβ : Formula
a_ihβ : aβ.predVarSet = β
β sub Ο aβ = aβ
h1 : aβ.not_.predVarSet = β
β’ sub Ο aβ.not_ = aβ.not_
case imp_
Ο : PredName β PredName
aβΒΉ aβ : Formula
a_ihβΒΉ : aβΒΉ.predVarSet = β
β sub Ο aβΒΉ = aβΒΉ
a_ihβ : aβ.predVarSet = β
β sub Ο aβ = aβ
h1 : (aβΒΉ.imp_ aβ).predVarSet = β
β’ sub Ο (aβΒΉ.imp_ aβ) = aβΒΉ.imp_ aβ
case and_
Ο : PredName β PredName
aβΒΉ aβ : Formula
a_ihβΒΉ : aβΒΉ.predVarSet = β
β sub Ο aβΒΉ = aβΒΉ
a_ihβ : aβ.predVarSet = β
β sub Ο aβ = aβ
h1 : (aβΒΉ.and_ aβ).predVarSet = β
β’ sub Ο (aβΒΉ.and_ aβ) = aβΒΉ.and_ aβ
case or_
Ο : PredName β PredName
aβΒΉ aβ : Formula
a_ihβΒΉ : aβΒΉ.predVarSet = β
β sub Ο aβΒΉ = aβΒΉ
a_ihβ : aβ.predVarSet = β
β sub Ο aβ = aβ
h1 : (aβΒΉ.or_ aβ).predVarSet = β
β’ sub Ο (aβΒΉ.or_ aβ) = aβΒΉ.or_ aβ
case iff_
Ο : PredName β PredName
aβΒΉ aβ : Formula
a_ihβΒΉ : aβΒΉ.predVarSet = β
β sub Ο aβΒΉ = aβΒΉ
a_ihβ : aβ.predVarSet = β
β sub Ο aβ = aβ
h1 : (aβΒΉ.iff_ aβ).predVarSet = β
β’ sub Ο (aβΒΉ.iff_ aβ) = aβΒΉ.iff_ aβ
case forall_
Ο : PredName β PredName
aβΒΉ : VarName
aβ : Formula
a_ihβ : aβ.predVarSet = β
β sub Ο aβ = aβ
h1 : (forall_ aβΒΉ aβ).predVarSet = β
β’ sub Ο (forall_ aβΒΉ aβ) = forall_ aβΒΉ aβ
case exists_
Ο : PredName β PredName
aβΒΉ : VarName
aβ : Formula
a_ihβ : aβ.predVarSet = β
β sub Ο aβ = aβ
h1 : (exists_ aβΒΉ aβ).predVarSet = β
β’ sub Ο (exists_ aβΒΉ aβ) = exists_ aβΒΉ aβ
case def_
Ο : PredName β PredName
aβΒΉ : DefName
aβ : List VarName
h1 : (def_ aβΒΉ aβ).predVarSet = β
β’ sub Ο (def_ aβΒΉ aβ) = def_ aβΒΉ aβ
|
Please generate a tactic in lean4 to solve the state.
STATE:
F : Formula
Ο : PredName β PredName
h1 : F.predVarSet = β
β’ sub Ο F = F
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
case pred_const_ X xs =>
simp only [sub]
|
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : (pred_const_ X xs).predVarSet = β
β’ sub Ο (pred_const_ X xs) = pred_const_ X xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : (pred_const_ X xs).predVarSet = β
β’ sub Ο (pred_const_ X xs) = pred_const_ X xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
case pred_var_ X xs =>
simp only [predVarSet] at h1
simp at h1
|
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : (pred_var_ X xs).predVarSet = β
β’ sub Ο (pred_var_ X xs) = pred_var_ X xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : (pred_var_ X xs).predVarSet = β
β’ sub Ο (pred_var_ X xs) = pred_var_ X xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
case eq_ x y =>
simp only [sub]
|
Ο : PredName β PredName
x y : VarName
h1 : (eq_ x y).predVarSet = β
β’ sub Ο (eq_ x y) = eq_ x y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
x y : VarName
h1 : (eq_ x y).predVarSet = β
β’ sub Ο (eq_ x y) = eq_ x y
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
case true_ | false_ =>
simp only [sub]
|
Ο : PredName β PredName
h1 : false_.predVarSet = β
β’ sub Ο false_ = false_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
h1 : false_.predVarSet = β
β’ sub Ο false_ = false_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
case not_ phi phi_ih =>
simp only [predVarSet] at h1
simp only [sub]
congr!
exact phi_ih h1
|
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.not_.predVarSet = β
β’ sub Ο phi.not_ = phi.not_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.not_.predVarSet = β
β’ sub Ο phi.not_ = phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
case forall_ x phi phi_ih | exists_ x phi phi_ih =>
simp only [predVarSet] at h1
simp only [sub]
congr!
exact phi_ih h1
|
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : (exists_ x phi).predVarSet = β
β’ sub Ο (exists_ x phi) = exists_ x phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : (exists_ x phi).predVarSet = β
β’ sub Ο (exists_ x phi) = exists_ x phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
case def_ X xs =>
simp only [sub]
|
Ο : PredName β PredName
X : DefName
xs : List VarName
h1 : (def_ X xs).predVarSet = β
β’ sub Ο (def_ X xs) = def_ X xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
X : DefName
xs : List VarName
h1 : (def_ X xs).predVarSet = β
β’ sub Ο (def_ X xs) = def_ X xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [sub]
|
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : (pred_const_ X xs).predVarSet = β
β’ sub Ο (pred_const_ X xs) = pred_const_ X xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : (pred_const_ X xs).predVarSet = β
β’ sub Ο (pred_const_ X xs) = pred_const_ X xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [predVarSet] at h1
|
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : (pred_var_ X xs).predVarSet = β
β’ sub Ο (pred_var_ X xs) = pred_var_ X xs
|
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : {(X, xs.length)} = β
β’ sub Ο (pred_var_ X xs) = pred_var_ X xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : (pred_var_ X xs).predVarSet = β
β’ sub Ο (pred_var_ X xs) = pred_var_ X xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp at h1
|
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : {(X, xs.length)} = β
β’ sub Ο (pred_var_ X xs) = pred_var_ X xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
X : PredName
xs : List VarName
h1 : {(X, xs.length)} = β
β’ sub Ο (pred_var_ X xs) = pred_var_ X xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [sub]
|
Ο : PredName β PredName
x y : VarName
h1 : (eq_ x y).predVarSet = β
β’ sub Ο (eq_ x y) = eq_ x y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
x y : VarName
h1 : (eq_ x y).predVarSet = β
β’ sub Ο (eq_ x y) = eq_ x y
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [sub]
|
Ο : PredName β PredName
h1 : false_.predVarSet = β
β’ sub Ο false_ = false_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
h1 : false_.predVarSet = β
β’ sub Ο false_ = false_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [predVarSet] at h1
|
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.not_.predVarSet = β
β’ sub Ο phi.not_ = phi.not_
|
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο phi.not_ = phi.not_
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.not_.predVarSet = β
β’ sub Ο phi.not_ = phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [sub]
|
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο phi.not_ = phi.not_
|
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ (sub Ο phi).not_ = phi.not_
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο phi.not_ = phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
congr!
|
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ (sub Ο phi).not_ = phi.not_
|
case h.e'_1
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο phi = phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ (sub Ο phi).not_ = phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
exact phi_ih h1
|
case h.e'_1
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο phi = phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_1
Ο : PredName β PredName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο phi = phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [predVarSet] at h1
|
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1 : (phi.iff_ psi).predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
|
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1 : phi.predVarSet βͺ psi.predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1 : (phi.iff_ psi).predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [Finset.union_eq_empty] at h1
|
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1 : phi.predVarSet βͺ psi.predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
|
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1 : phi.predVarSet = β
β§ psi.predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1 : phi.predVarSet βͺ psi.predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
cases h1
|
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1 : phi.predVarSet = β
β§ psi.predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
|
case intro
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
leftβ : phi.predVarSet = β
rightβ : psi.predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1 : phi.predVarSet = β
β§ psi.predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [sub]
|
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
|
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ (sub Ο phi).iff_ (sub Ο psi) = phi.iff_ psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ sub Ο (phi.iff_ psi) = phi.iff_ psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
congr!
|
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ (sub Ο phi).iff_ (sub Ο psi) = phi.iff_ psi
|
case h.e'_1
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ sub Ο phi = phi
case h.e'_2
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ sub Ο psi = psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ (sub Ο phi).iff_ (sub Ο psi) = phi.iff_ psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
exact phi_ih h1_left
|
case h.e'_1
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ sub Ο phi = phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_1
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ sub Ο phi = phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
exact psi_ih h1_right
|
case h.e'_2
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ sub Ο psi = psi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2
Ο : PredName β PredName
phi psi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
psi_ih : psi.predVarSet = β
β sub Ο psi = psi
h1_left : phi.predVarSet = β
h1_right : psi.predVarSet = β
β’ sub Ο psi = psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [predVarSet] at h1
|
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : (exists_ x phi).predVarSet = β
β’ sub Ο (exists_ x phi) = exists_ x phi
|
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο (exists_ x phi) = exists_ x phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : (exists_ x phi).predVarSet = β
β’ sub Ο (exists_ x phi) = exists_ x phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [sub]
|
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο (exists_ x phi) = exists_ x phi
|
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ exists_ x (sub Ο phi) = exists_ x phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο (exists_ x phi) = exists_ x phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
congr!
|
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ exists_ x (sub Ο phi) = exists_ x phi
|
case h.e'_2
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο phi = phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ exists_ x (sub Ο phi) = exists_ x phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
exact phi_ih h1
|
case h.e'_2
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο phi = phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_2
Ο : PredName β PredName
x : VarName
phi : Formula
phi_ih : phi.predVarSet = β
β sub Ο phi = phi
h1 : phi.predVarSet = β
β’ sub Ο phi = phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.sub_no_predVar
|
[47, 1]
|
[91, 20]
|
simp only [sub]
|
Ο : PredName β PredName
X : DefName
xs : List VarName
h1 : (def_ X xs).predVarSet = β
β’ sub Ο (def_ X xs) = def_ X xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : PredName β PredName
X : DefName
xs : List VarName
h1 : (def_ X xs).predVarSet = β
β’ sub Ο (def_ X xs) = def_ X xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
induction E generalizing F V
|
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
Ο : PredName β PredName
F : Formula
β’ Holds D I V E (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V E (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V E F
|
case nil
D : Type
I : Interpretation D
Ο : PredName β PredName
V : VarAssignment D
F : Formula
β’ Holds D I V [] (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V [] (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V [] F
case cons
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
F : Formula
β’ Holds D I V (headβ :: tailβ) (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) F
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
Ο : PredName β PredName
F : Formula
β’ Holds D I V E (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V E (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V E F
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case nil.def_ X xs =>
simp only [sub]
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V [] (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V [] (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V [] (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V [] (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V [] (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V [] (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case cons.def_ hd tl ih X xs =>
simp only [Holds] at ih
simp at ih
simp only [sub]
simp only [Holds]
split_ifs
case _ c1 =>
specialize ih (Function.updateListITE V hd.args (List.map V xs)) hd.q
simp only [sub_no_predVar hd.q Ο hd.h2] at ih
apply ih
case _ c1 =>
specialize ih V (def_ X xs)
simp only [sub] at ih
exact ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tl (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tl F
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (hd :: tl) (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tl (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tl F
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (hd :: tl) (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
induction F generalizing V
|
case cons
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
F : Formula
β’ Holds D I V (headβ :: tailβ) (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) F
|
case cons.pred_const_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβΒΉ : PredName
aβ : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (pred_const_ aβΒΉ aβ)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_const_ aβΒΉ aβ)
case cons.pred_var_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβΒΉ : PredName
aβ : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (pred_var_ aβΒΉ aβ)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ aβΒΉ aβ)
case cons.eq_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβΒΉ aβ : VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (eq_ aβΒΉ aβ)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (eq_ aβΒΉ aβ)
case cons.true_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο true_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) true_
case cons.false_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο false_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) false_
case cons.not_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβ : Formula
a_ihβ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβ
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο aβ.not_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβ.not_
case cons.imp_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβΒΉ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβΒΉ
a_ihβ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβ
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (aβΒΉ.imp_ aβ)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (aβΒΉ.imp_ aβ)
case cons.and_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβΒΉ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβΒΉ
a_ihβ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβ
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (aβΒΉ.and_ aβ)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (aβΒΉ.and_ aβ)
case cons.or_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβΒΉ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβΒΉ
a_ihβ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβ
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (aβΒΉ.or_ aβ)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (aβΒΉ.or_ aβ)
case cons.iff_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβΒΉ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβΒΉ
a_ihβ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβ
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (aβΒΉ.iff_ aβ)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (aβΒΉ.iff_ aβ)
case cons.forall_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβΒΉ : VarName
aβ : Formula
a_ihβ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβ
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (forall_ aβΒΉ aβ)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (forall_ aβΒΉ aβ)
case cons.exists_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβΒΉ : VarName
aβ : Formula
a_ihβ :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο aβ) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) aβ
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (exists_ aβΒΉ aβ)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ aβΒΉ aβ)
case cons.def_
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
aβΒΉ : DefName
aβ : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (def_ aβΒΉ aβ)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (def_ aβΒΉ aβ)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case cons
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
F : Formula
β’ Holds D I V (headβ :: tailβ) (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) F
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case pred_const_ X xs =>
simp only [sub]
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (pred_const_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_const_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (pred_const_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_const_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case pred_var_ X xs =>
simp only [sub]
split_ifs
case pos c1 =>
simp only [Holds]
simp
simp only [if_pos c1]
case neg c1 =>
simp only [Holds]
simp
simp only [if_neg c1]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (pred_var_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (pred_var_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case eq_ x y =>
simp only [sub]
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x y : VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (eq_ x y)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (eq_ x y)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x y : VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (eq_ x y)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (eq_ x y)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case true_ | false_ =>
simp only [sub]
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο false_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) false_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο false_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) false_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case not_ phi phi_ih =>
simp only [Holds] at phi_ih
simp only [sub]
simp only [Holds]
congr! 1
apply phi_ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο phi.not_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi.not_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο phi.not_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case forall_ x phi phi_ih | exists_ x phi phi_ih =>
simp only [Holds] at phi_ih
simp only [sub]
simp only [Holds]
first | apply forall_congr' | apply exists_congr
intros d
apply phi_ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (exists_ x phi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ x phi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (exists_ x phi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ x phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (pred_const_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_const_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (pred_const_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_const_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (pred_const_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_const_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (pred_const_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_const_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (pred_const_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_const_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (pred_var_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (if xs = [] then pred_var_ (Ο X) [] else pred_var_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (pred_var_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
split_ifs
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (if xs = [] then pred_var_ (Ο X) [] else pred_var_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
|
case pos
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
hβ : xs = []
β’ Holds D I V (headβ :: tailβ) (pred_var_ (Ο X) []) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
case neg
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
hβ : Β¬xs = []
β’ Holds D I V (headβ :: tailβ) (pred_var_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (if xs = [] then pred_var_ (Ο X) [] else pred_var_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case pos c1 =>
simp only [Holds]
simp
simp only [if_pos c1]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : xs = []
β’ Holds D I V (headβ :: tailβ) (pred_var_ (Ο X) []) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : xs = []
β’ Holds D I V (headβ :: tailβ) (pred_var_ (Ο X) []) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case neg c1 =>
simp only [Holds]
simp
simp only [if_neg c1]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : Β¬xs = []
β’ Holds D I V (headβ :: tailβ) (pred_var_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : Β¬xs = []
β’ Holds D I V (headβ :: tailβ) (pred_var_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : xs = []
β’ Holds D I V (headβ :: tailβ) (pred_var_ (Ο X) []) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : xs = []
β’ I.pred_var_ (Ο X) (List.map V []) β
if List.map V xs = [] then I.pred_var_ (Ο X) (List.map V []) else I.pred_var_ X (List.map V xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : xs = []
β’ Holds D I V (headβ :: tailβ) (pred_var_ (Ο X) []) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : xs = []
β’ I.pred_var_ (Ο X) (List.map V []) β
if List.map V xs = [] then I.pred_var_ (Ο X) (List.map V []) else I.pred_var_ X (List.map V xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : xs = []
β’ I.pred_var_ (Ο X) [] β if xs = [] then I.pred_var_ (Ο X) [] else I.pred_var_ X (List.map V xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : xs = []
β’ I.pred_var_ (Ο X) (List.map V []) β
if List.map V xs = [] then I.pred_var_ (Ο X) (List.map V []) else I.pred_var_ X (List.map V xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [if_pos c1]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : xs = []
β’ I.pred_var_ (Ο X) [] β if xs = [] then I.pred_var_ (Ο X) [] else I.pred_var_ X (List.map V xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : xs = []
β’ I.pred_var_ (Ο X) [] β if xs = [] then I.pred_var_ (Ο X) [] else I.pred_var_ X (List.map V xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : Β¬xs = []
β’ Holds D I V (headβ :: tailβ) (pred_var_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : Β¬xs = []
β’ I.pred_var_ X (List.map V xs) β
if List.map V xs = [] then I.pred_var_ (Ο X) (List.map V []) else I.pred_var_ X (List.map V xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : Β¬xs = []
β’ Holds D I V (headβ :: tailβ) (pred_var_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : Β¬xs = []
β’ I.pred_var_ X (List.map V xs) β
if List.map V xs = [] then I.pred_var_ (Ο X) (List.map V []) else I.pred_var_ X (List.map V xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : Β¬xs = []
β’ I.pred_var_ X (List.map V xs) β if xs = [] then I.pred_var_ (Ο X) [] else I.pred_var_ X (List.map V xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : Β¬xs = []
β’ I.pred_var_ X (List.map V xs) β
if List.map V xs = [] then I.pred_var_ (Ο X) (List.map V []) else I.pred_var_ X (List.map V xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [if_neg c1]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : Β¬xs = []
β’ I.pred_var_ X (List.map V xs) β if xs = [] then I.pred_var_ (Ο X) [] else I.pred_var_ X (List.map V xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
X : PredName
xs : List VarName
V : VarAssignment D
c1 : Β¬xs = []
β’ I.pred_var_ X (List.map V xs) β if xs = [] then I.pred_var_ (Ο X) [] else I.pred_var_ X (List.map V xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x y : VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (eq_ x y)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (eq_ x y)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x y : VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (eq_ x y) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (eq_ x y)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x y : VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (eq_ x y)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (eq_ x y)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x y : VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (eq_ x y) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (eq_ x y)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x y : VarName
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (eq_ x y) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (eq_ x y)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο false_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) false_
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) false_ β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) false_
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο false_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) false_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) false_ β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) false_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) false_ β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) false_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds] at phi_ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο phi.not_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi.not_
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi.not_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi.not_
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο phi.not_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi.not_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi.not_
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi).not_ β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi.not_
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi.not_) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi).not_ β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi.not_
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Β¬Holds D I V (headβ :: tailβ) (sub Ο phi) β
Β¬Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi).not_ β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi.not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
congr! 1
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Β¬Holds D I V (headβ :: tailβ) (sub Ο phi) β
Β¬Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
|
case a.h.e'_1.a
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Β¬Holds D I V (headβ :: tailβ) (sub Ο phi) β
Β¬Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
apply phi_ih
|
case a.h.e'_1.a
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) 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
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds] at phi_ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (phi.iff_ psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο (phi.iff_ psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (phi.iff_ psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds] at psi_ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο (phi.iff_ psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) (sub Ο (phi.iff_ psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο (phi.iff_ psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) (sub Ο (phi.iff_ psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) ((sub Ο phi).iff_ (sub Ο psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) (sub Ο (phi.iff_ psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) ((sub Ο phi).iff_ (sub Ο psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ (Holds D I V (headβ :: tailβ) (sub Ο phi) β Holds D I V (headβ :: tailβ) (sub Ο psi)) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) ((sub Ο phi).iff_ (sub Ο psi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (phi.iff_ psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
congr! 1
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ (Holds D I V (headβ :: tailβ) (sub Ο phi) β Holds D I V (headβ :: tailβ) (sub Ο psi)) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi)
|
case a.h.e'_1.a
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
case a.h.e'_2.a
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ (Holds D I V (headβ :: tailβ) (sub Ο phi) β Holds D I V (headβ :: tailβ) (sub Ο psi)) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
apply phi_ih
|
case a.h.e'_1.a
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) 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
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
apply psi_ih
|
case a.h.e'_2.a
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) 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
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
phi psi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
psi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
β’ Holds D I V (headβ :: tailβ) (sub Ο psi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds] at phi_ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (exists_ x phi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ x phi)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο (exists_ x phi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ x phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
V : VarAssignment D
β’ Holds D I V (headβ :: tailβ) (sub Ο (exists_ x phi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ x phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο (exists_ x phi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ x phi)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (exists_ x (sub Ο phi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ x phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (sub Ο (exists_ x phi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ x phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (exists_ x (sub Ο phi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ x phi)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ (β d, Holds D I (Function.updateITE V x d) (headβ :: tailβ) (sub Ο phi)) β
β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x d) (headβ :: tailβ) phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ Holds D I V (headβ :: tailβ) (exists_ x (sub Ο phi)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds =>
if ds = [] then Holds D I V (headβ :: tailβ) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (headβ :: tailβ) (exists_ x phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
first | apply forall_congr' | apply exists_congr
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ (β d, Holds D I (Function.updateITE V x d) (headβ :: tailβ) (sub Ο phi)) β
β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x d) (headβ :: tailβ) phi
|
case h
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ β (a : D),
Holds D I (Function.updateITE V x a) (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x a) (headβ :: tailβ) phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ (β d, Holds D I (Function.updateITE V x d) (headβ :: tailβ) (sub Ο phi)) β
β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x d) (headβ :: tailβ) phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
intros d
|
case h
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ β (a : D),
Holds D I (Function.updateITE V x a) (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x a) (headβ :: tailβ) phi
|
case h
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
d : D
β’ Holds D I (Function.updateITE V x d) (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x d) (headβ :: tailβ) phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ β (a : D),
Holds D I (Function.updateITE V x a) (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x a) (headβ :: tailβ) phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
apply phi_ih
|
case h
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
d : D
β’ Holds D I (Function.updateITE V x d) (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x d) (headβ :: tailβ) phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
d : D
β’ Holds D I (Function.updateITE V x d) (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x d) (headβ :: tailβ) phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
apply forall_congr'
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ (β (d : D), Holds D I (Function.updateITE V x d) (headβ :: tailβ) (sub Ο phi)) β
β (d : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x d) (headβ :: tailβ) phi
|
case h
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ β (a : D),
Holds D I (Function.updateITE V x a) (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x a) (headβ :: tailβ) phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ (β (d : D), Holds D I (Function.updateITE V x d) (headβ :: tailβ) (sub Ο phi)) β
β (d : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x d) (headβ :: tailβ) phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
apply exists_congr
|
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ (β d, Holds D I (Function.updateITE V x d) (headβ :: tailβ) (sub Ο phi)) β
β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x d) (headβ :: tailβ) phi
|
case h
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ β (a : D),
Holds D I (Function.updateITE V x a) (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x a) (headβ :: tailβ) phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
headβ : Definition
tailβ : List Definition
tail_ihβ :
β (V : VarAssignment D) (F : Formula),
Holds D I V tailβ (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tailβ (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tailβ F
x : VarName
phi : Formula
V : VarAssignment D
phi_ih :
β (V : VarAssignment D),
Holds D I V (headβ :: tailβ) (sub Ο phi) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V (headβ :: tailβ) phi
β’ (β d, Holds D I (Function.updateITE V x d) (headβ :: tailβ) (sub Ο phi)) β
β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateITE V x d) (headβ :: tailβ) phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V [] (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V [] (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V [] (def_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V [] (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V [] (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V [] (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V [] (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V [] (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V [] (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V [] (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V [] (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V [] (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V [] (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V [] (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V [] (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds] at ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tl (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tl F
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (hd :: tl) (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl F
β’ Holds D I V (hd :: tl) (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V tl (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V tl F
X : DefName
xs : List VarName
V : VarAssignment D
β’ Holds D I V (hd :: tl) (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp at ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl F
β’ Holds D I V (hd :: tl) (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
β’ Holds D I V (hd :: tl) (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl F
β’ Holds D I V (hd :: tl) (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
β’ Holds D I V (hd :: tl) (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
β’ Holds D I V (hd :: tl) (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
β’ Holds D I V (hd :: tl) (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
β’ Holds D I V (hd :: tl) (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
β’ (if X = hd.name β§ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else Holds D I V tl (def_ X xs)) β
if X = hd.name β§ xs.length = hd.args.length then
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
β’ Holds D I V (hd :: tl) (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then Holds D I V (hd :: tl) (pred_var_ (Ο P) []) else I.pred_var_ P ds }
V (hd :: tl) (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
split_ifs
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
β’ (if X = hd.name β§ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else Holds D I V tl (def_ X xs)) β
if X = hd.name β§ xs.length = hd.args.length then
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
|
case pos
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
hβ : X = hd.name β§ xs.length = hd.args.length
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
case neg
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
hβ : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
β’ (if X = hd.name β§ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else Holds D I V tl (def_ X xs)) β
if X = hd.name β§ xs.length = hd.args.length then
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case _ c1 =>
specialize ih (Function.updateListITE V hd.args (List.map V xs)) hd.q
simp only [sub_no_predVar hd.q Ο hd.h2] at ih
apply ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
c1 : X = hd.name β§ xs.length = hd.args.length
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
c1 : X = hd.name β§ xs.length = hd.args.length
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
case _ c1 =>
specialize ih V (def_ X xs)
simp only [sub] at ih
exact ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
specialize ih (Function.updateListITE V hd.args (List.map V xs)) hd.q
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
c1 : X = hd.name β§ xs.length = hd.args.length
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : X = hd.name β§ xs.length = hd.args.length
ih :
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl (sub Ο hd.q) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
c1 : X = hd.name β§ xs.length = hd.args.length
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub_no_predVar hd.q Ο hd.h2] at ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : X = hd.name β§ xs.length = hd.args.length
ih :
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl (sub Ο hd.q) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : X = hd.name β§ xs.length = hd.args.length
ih :
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : X = hd.name β§ xs.length = hd.args.length
ih :
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl (sub Ο hd.q) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
apply ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : X = hd.name β§ xs.length = hd.args.length
ih :
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : X = hd.name β§ xs.length = hd.args.length
ih :
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
specialize ih V (def_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
ih :
Holds D I V tl (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl (def_ X xs)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
ih :
β (V : VarAssignment D) (F : Formula),
Holds D I V tl (sub Ο F) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl F
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
simp only [sub] at ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
ih :
Holds D I V tl (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl (def_ X xs)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
ih :
Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl (def_ X xs)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
ih :
Holds D I V tl (sub Ο (def_ X xs)) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl (def_ X xs)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_theorem
|
[94, 1]
|
[182, 15]
|
exact ih
|
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
ih :
Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl (def_ X xs)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
Ο : PredName β PredName
hd : Definition
tl : List Definition
X : DefName
xs : List VarName
V : VarAssignment D
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
ih :
Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) [] else I.pred_var_ P ds }
V tl (def_ X xs)
β’ Holds D I V tl (def_ X xs) β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun P ds => if ds = [] then I.pred_var_ (Ο P) (List.map V []) else I.pred_var_ P ds }
V tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_is_valid
|
[185, 1]
|
[196, 11]
|
simp only [IsValid] at h1
|
F : Formula
Ο : PredName β PredName
h1 : F.IsValid
β’ (sub Ο F).IsValid
|
F : Formula
Ο : PredName β PredName
h1 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
β’ (sub Ο F).IsValid
|
Please generate a tactic in lean4 to solve the state.
STATE:
F : Formula
Ο : PredName β PredName
h1 : F.IsValid
β’ (sub Ο F).IsValid
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_is_valid
|
[185, 1]
|
[196, 11]
|
simp only [IsValid]
|
F : Formula
Ο : PredName β PredName
h1 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
β’ (sub Ο F).IsValid
|
F : Formula
Ο : PredName β PredName
h1 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
β’ β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (sub Ο F)
|
Please generate a tactic in lean4 to solve the state.
STATE:
F : Formula
Ο : PredName β PredName
h1 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
β’ (sub Ο F).IsValid
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Prop/All/Rec/Sub.lean
|
FOL.NV.Sub.Prop.All.Rec.substitution_is_valid
|
[185, 1]
|
[196, 11]
|
intro D I V E
|
F : Formula
Ο : PredName β PredName
h1 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
β’ β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (sub Ο F)
|
F : Formula
Ο : PredName β PredName
h1 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
β’ Holds D I V E (sub Ο F)
|
Please generate a tactic in lean4 to solve the state.
STATE:
F : Formula
Ο : PredName β PredName
h1 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
β’ β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (sub Ο F)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.