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/LN/Paper.lean
|
LN.VarSubstFreeVarSet'
|
[540, 1]
|
[562, 33]
|
simp only [Var.subst]
|
z : String
t : Var
x : String
β’ (free_ x).freeVarSet \ {free_ z} β ((free_ z).subst t (free_ x)).freeVarSet
|
z : String
t : Var
x : String
β’ (free_ x).freeVarSet \ {free_ z} β (if free_ z = free_ x then t else free_ x).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
β’ (free_ x).freeVarSet \ {free_ z} β ((free_ z).subst t (free_ x)).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarSubstFreeVarSet'
|
[540, 1]
|
[562, 33]
|
split_ifs
|
z : String
t : Var
x : String
β’ (free_ x).freeVarSet \ {free_ z} β (if free_ z = free_ x then t else free_ x).freeVarSet
|
case pos
z : String
t : Var
x : String
hβ : free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ z} β t.freeVarSet
case neg
z : String
t : Var
x : String
hβ : Β¬free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ z} β (free_ x).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
β’ (free_ x).freeVarSet \ {free_ z} β (if free_ z = free_ x then t else free_ x).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarSubstFreeVarSet'
|
[540, 1]
|
[562, 33]
|
case pos c1 =>
simp only [c1]
conv =>
lhs
simp only [Var.freeVarSet]
simp
|
z : String
t : Var
x : String
c1 : free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ z} β t.freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
c1 : free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ z} β t.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarSubstFreeVarSet'
|
[540, 1]
|
[562, 33]
|
case neg c1 =>
simp only [Var.freeVarSet]
exact Finset.sdiff_subset {free_ x} {free_ z}
|
z : String
t : Var
x : String
c1 : Β¬free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ z} β (free_ x).freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
c1 : Β¬free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ z} β (free_ x).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarSubstFreeVarSet'
|
[540, 1]
|
[562, 33]
|
simp only [c1]
|
z : String
t : Var
x : String
c1 : free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ z} β t.freeVarSet
|
z : String
t : Var
x : String
c1 : free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ x} β t.freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
c1 : free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ z} β t.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarSubstFreeVarSet'
|
[540, 1]
|
[562, 33]
|
conv =>
lhs
simp only [Var.freeVarSet]
|
z : String
t : Var
x : String
c1 : free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ x} β t.freeVarSet
|
z : String
t : Var
x : String
c1 : free_ z = free_ x
β’ {free_ x} \ {free_ x} β t.freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
c1 : free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ x} β t.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarSubstFreeVarSet'
|
[540, 1]
|
[562, 33]
|
simp
|
z : String
t : Var
x : String
c1 : free_ z = free_ x
β’ {free_ x} \ {free_ x} β t.freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
c1 : free_ z = free_ x
β’ {free_ x} \ {free_ x} β t.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarSubstFreeVarSet'
|
[540, 1]
|
[562, 33]
|
simp only [Var.freeVarSet]
|
z : String
t : Var
x : String
c1 : Β¬free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ z} β (free_ x).freeVarSet
|
z : String
t : Var
x : String
c1 : Β¬free_ z = free_ x
β’ {free_ x} \ {free_ z} β {free_ x}
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
c1 : Β¬free_ z = free_ x
β’ (free_ x).freeVarSet \ {free_ z} β (free_ x).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarSubstFreeVarSet'
|
[540, 1]
|
[562, 33]
|
exact Finset.sdiff_subset {free_ x} {free_ z}
|
z : String
t : Var
x : String
c1 : Β¬free_ z = free_ x
β’ {free_ x} \ {free_ z} β {free_ x}
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
c1 : Β¬free_ z = free_ x
β’ {free_ x} \ {free_ z} β {free_ x}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarSubstFreeVarSet'
|
[540, 1]
|
[562, 33]
|
conv =>
lhs
simp only [Var.freeVarSet]
|
z : String
t : Var
i : β
β’ (bound_ i).freeVarSet \ {free_ z} β ((free_ z).subst t (bound_ i)).freeVarSet
|
z : String
t : Var
i : β
β’ β
\ {free_ z} β ((free_ z).subst t (bound_ i)).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
i : β
β’ (bound_ i).freeVarSet \ {free_ z} β ((free_ z).subst t (bound_ i)).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
induction F
|
z : String
t : Var
F : Formula
β’ F.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t F).freeVarSet
|
case pred_
z : String
t : Var
aβΒΉ : String
aβ : List Var
β’ (pred_ aβΒΉ aβ).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (pred_ aβΒΉ aβ)).freeVarSet
case not_
z : String
t : Var
aβ : Formula
a_ihβ : aβ.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t aβ).freeVarSet
β’ aβ.not_.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t aβ.not_).freeVarSet
case imp_
z : String
t : Var
aβΒΉ aβ : Formula
a_ihβΒΉ : aβΒΉ.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t aβΒΉ).freeVarSet
a_ihβ : aβ.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t aβ).freeVarSet
β’ (aβΒΉ.imp_ aβ).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (aβΒΉ.imp_ aβ)).freeVarSet
case forall_
z : String
t : Var
aβΒΉ : String
aβ : Formula
a_ihβ : aβ.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t aβ).freeVarSet
β’ (forall_ aβΒΉ aβ).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (forall_ aβΒΉ aβ)).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
F : Formula
β’ F.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t F).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
case pred_ X vs =>
simp only [Formula.subst]
simp only [Formula.freeVarSet]
induction vs
case nil =>
simp
case cons hd tl ih =>
simp
have s1 : (Var.freeVarSet hd βͺ Finset.biUnion (List.toFinset tl) Var.freeVarSet) \ {free_ z} = (Var.freeVarSet hd \ {free_ z}) βͺ ((Finset.biUnion (List.toFinset tl) Var.freeVarSet) \ {free_ z})
exact Finset.union_sdiff_distrib (Var.freeVarSet hd) (Finset.biUnion (List.toFinset tl) Var.freeVarSet) {free_ z}
simp only [s1]
exact Finset.union_subset_union (VarSubstFreeVarSet' z t hd) ih
|
z : String
t : Var
X : String
vs : List Var
β’ (pred_ X vs).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (pred_ X vs)).freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
vs : List Var
β’ (pred_ X vs).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (pred_ X vs)).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
case not_ phi phi_ih =>
simp only [Formula.subst]
simp only [Formula.freeVarSet]
exact phi_ih
|
z : String
t : Var
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.not_.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi.not_).freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.not_.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi.not_).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
case forall_ x phi phi_ih =>
simp only [Formula.subst]
simp only [Formula.freeVarSet]
exact phi_ih
|
z : String
t : Var
x : String
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ (forall_ x phi).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (forall_ x phi)).freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ (forall_ x phi).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (forall_ x phi)).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp only [Formula.subst]
|
z : String
t : Var
X : String
vs : List Var
β’ (pred_ X vs).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (pred_ X vs)).freeVarSet
|
z : String
t : Var
X : String
vs : List Var
β’ (pred_ X vs).freeVarSet \ {free_ z} β (pred_ X (List.map ((free_ z).subst t) vs)).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
vs : List Var
β’ (pred_ X vs).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (pred_ X vs)).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp only [Formula.freeVarSet]
|
z : String
t : Var
X : String
vs : List Var
β’ (pred_ X vs).freeVarSet \ {free_ z} β (pred_ X (List.map ((free_ z).subst t) vs)).freeVarSet
|
z : String
t : Var
X : String
vs : List Var
β’ vs.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) vs).toFinset.biUnion Var.freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
vs : List Var
β’ (pred_ X vs).freeVarSet \ {free_ z} β (pred_ X (List.map ((free_ z).subst t) vs)).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
induction vs
|
z : String
t : Var
X : String
vs : List Var
β’ vs.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) vs).toFinset.biUnion Var.freeVarSet
|
case nil
z : String
t : Var
X : String
β’ [].toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) []).toFinset.biUnion Var.freeVarSet
case cons
z : String
t : Var
X : String
headβ : Var
tailβ : List Var
tail_ihβ :
tailβ.toFinset.biUnion Var.freeVarSet \ {free_ z} β
(List.map ((free_ z).subst t) tailβ).toFinset.biUnion Var.freeVarSet
β’ (headβ :: tailβ).toFinset.biUnion Var.freeVarSet \ {free_ z} β
(List.map ((free_ z).subst t) (headβ :: tailβ)).toFinset.biUnion Var.freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
vs : List Var
β’ vs.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) vs).toFinset.biUnion Var.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
case nil =>
simp
|
z : String
t : Var
X : String
β’ [].toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) []).toFinset.biUnion Var.freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
β’ [].toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) []).toFinset.biUnion Var.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
case cons hd tl ih =>
simp
have s1 : (Var.freeVarSet hd βͺ Finset.biUnion (List.toFinset tl) Var.freeVarSet) \ {free_ z} = (Var.freeVarSet hd \ {free_ z}) βͺ ((Finset.biUnion (List.toFinset tl) Var.freeVarSet) \ {free_ z})
exact Finset.union_sdiff_distrib (Var.freeVarSet hd) (Finset.biUnion (List.toFinset tl) Var.freeVarSet) {free_ z}
simp only [s1]
exact Finset.union_subset_union (VarSubstFreeVarSet' z t hd) ih
|
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
β’ (hd :: tl).toFinset.biUnion Var.freeVarSet \ {free_ z} β
(List.map ((free_ z).subst t) (hd :: tl)).toFinset.biUnion Var.freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
β’ (hd :: tl).toFinset.biUnion Var.freeVarSet \ {free_ z} β
(List.map ((free_ z).subst t) (hd :: tl)).toFinset.biUnion Var.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp
|
z : String
t : Var
X : String
β’ [].toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) []).toFinset.biUnion Var.freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
β’ [].toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) []).toFinset.biUnion Var.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp
|
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
β’ (hd :: tl).toFinset.biUnion Var.freeVarSet \ {free_ z} β
(List.map ((free_ z).subst t) (hd :: tl)).toFinset.biUnion Var.freeVarSet
|
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
β’ (hd :: tl).toFinset.biUnion Var.freeVarSet \ {free_ z} β
(List.map ((free_ z).subst t) (hd :: tl)).toFinset.biUnion Var.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
have s1 : (Var.freeVarSet hd βͺ Finset.biUnion (List.toFinset tl) Var.freeVarSet) \ {free_ z} = (Var.freeVarSet hd \ {free_ z}) βͺ ((Finset.biUnion (List.toFinset tl) Var.freeVarSet) \ {free_ z})
|
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
|
case s1
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
s1 :
(hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
exact Finset.union_sdiff_distrib (Var.freeVarSet hd) (Finset.biUnion (List.toFinset tl) Var.freeVarSet) {free_ z}
|
case s1
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
s1 :
(hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
|
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
s1 :
(hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
s1 :
(hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp only [s1]
|
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
s1 :
(hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
|
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
s1 :
(hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
β’ hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
s1 :
(hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
β’ (hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
exact Finset.union_subset_union (VarSubstFreeVarSet' z t hd) ih
|
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
s1 :
(hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
β’ hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
X : String
hd : Var
tl : List Var
ih : tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
s1 :
(hd.freeVarSet βͺ tl.toFinset.biUnion Var.freeVarSet) \ {free_ z} =
hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z}
β’ hd.freeVarSet \ {free_ z} βͺ tl.toFinset.biUnion Var.freeVarSet \ {free_ z} β
((free_ z).subst t hd).freeVarSet βͺ (List.map ((free_ z).subst t) tl).toFinset.biUnion Var.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp only [Formula.subst]
|
z : String
t : Var
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.not_.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi.not_).freeVarSet
|
z : String
t : Var
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.not_.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).not_.freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.not_.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi.not_).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp only [Formula.freeVarSet]
|
z : String
t : Var
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.not_.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).not_.freeVarSet
|
z : String
t : Var
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.not_.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).not_.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
exact phi_ih
|
z : String
t : Var
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp only [Formula.subst]
|
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ (phi.imp_ psi).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (phi.imp_ psi)).freeVarSet
|
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ (phi.imp_ psi).freeVarSet \ {free_ z} β
((Formula.subst (free_ z) t phi).imp_ (Formula.subst (free_ z) t psi)).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ (phi.imp_ psi).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (phi.imp_ psi)).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp only [Formula.freeVarSet]
|
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ (phi.imp_ psi).freeVarSet \ {free_ z} β
((Formula.subst (free_ z) t phi).imp_ (Formula.subst (free_ z) t psi)).freeVarSet
|
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ (phi.freeVarSet βͺ psi.freeVarSet) \ {free_ z} β
(Formula.subst (free_ z) t phi).freeVarSet βͺ (Formula.subst (free_ z) t psi).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ (phi.imp_ psi).freeVarSet \ {free_ z} β
((Formula.subst (free_ z) t phi).imp_ (Formula.subst (free_ z) t psi)).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
apply Finset.diff_union_subset
|
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ (phi.freeVarSet βͺ psi.freeVarSet) \ {free_ z} β
(Formula.subst (free_ z) t phi).freeVarSet βͺ (Formula.subst (free_ z) t psi).freeVarSet
|
case h1
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
case h2
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ (phi.freeVarSet βͺ psi.freeVarSet) \ {free_ z} β
(Formula.subst (free_ z) t phi).freeVarSet βͺ (Formula.subst (free_ z) t psi).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
apply phi_ih
|
case h1
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
apply psi_ih
|
case h2
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
z : String
t : Var
phi psi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
psi_ih : psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
β’ psi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t psi).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp only [Formula.subst]
|
z : String
t : Var
x : String
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ (forall_ x phi).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (forall_ x phi)).freeVarSet
|
z : String
t : Var
x : String
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ (forall_ x phi).freeVarSet \ {free_ z} β (forall_ x (Formula.subst (free_ z) t phi)).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ (forall_ x phi).freeVarSet \ {free_ z} β (Formula.subst (free_ z) t (forall_ x phi)).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
simp only [Formula.freeVarSet]
|
z : String
t : Var
x : String
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ (forall_ x phi).freeVarSet \ {free_ z} β (forall_ x (Formula.subst (free_ z) t phi)).freeVarSet
|
z : String
t : Var
x : String
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ (forall_ x phi).freeVarSet \ {free_ z} β (forall_ x (Formula.subst (free_ z) t phi)).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.FormulaSubstFreeVarSet'
|
[565, 1]
|
[600, 17]
|
exact phi_ih
|
z : String
t : Var
x : String
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
z : String
t : Var
x : String
phi : Formula
phi_ih : phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
β’ phi.freeVarSet \ {free_ z} β (Formula.subst (free_ z) t phi).freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
cases v
|
v : Var
Ο : String β String
j : β
z : String
h1 : Ο z = z
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) v) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) v)
|
case free_
Ο : String β String
j : β
z : String
h1 : Ο z = z
aβ : String
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) (free_ aβ)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (free_ aβ))
case bound_
Ο : String β String
j : β
z : String
h1 : Ο z = z
aβ : β
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) (bound_ aβ)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ aβ))
|
Please generate a tactic in lean4 to solve the state.
STATE:
v : Var
Ο : String β String
j : β
z : String
h1 : Ο z = z
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) v) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) v)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
case free_ x =>
conv =>
lhs
simp only [Var.open]
simp only [Var.substFun]
simp only [str_fun_to_var_fun]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
x : String
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) (free_ x)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (free_ x))
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
x : String
β’ free_ (Ο x) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (free_ x))
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
x : String
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) (free_ x)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (free_ x))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
case bound_ i =>
conv =>
lhs
simp only [Var.open]
split_ifs
case pos c1 =>
simp only [Var.substFun]
simp only [Var.open]
simp only [if_pos c1]
case pos c1 c2 =>
simp only [Var.substFun]
simp only [str_fun_to_var_fun]
simp only [Var.open]
simp only [if_neg c1]
simp only [if_pos c2]
simp only [h1]
case neg c1 c2 =>
simp only [Var.substFun]
simp only [Var.open]
simp only [if_neg c1]
simp only [if_neg c2]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) (bound_ i)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) (bound_ i)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
conv =>
lhs
simp only [Var.open]
simp only [Var.substFun]
simp only [str_fun_to_var_fun]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
x : String
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) (free_ x)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (free_ x))
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
x : String
β’ free_ (Ο x) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (free_ x))
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
x : String
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) (free_ x)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (free_ x))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
conv =>
lhs
simp only [Var.open]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) (bound_ i)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
β’ Var.substFun (str_fun_to_var_fun Ο) (if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
β’ Var.substFun (str_fun_to_var_fun Ο) (Var.open j (free_ z) (bound_ i)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
split_ifs
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
β’ Var.substFun (str_fun_to_var_fun Ο) (if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
case pos
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
hβ : i < j
β’ Var.substFun (str_fun_to_var_fun Ο) (bound_ i) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
case pos
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
hβΒΉ : Β¬i < j
hβ : i = j
β’ Var.substFun (str_fun_to_var_fun Ο) (free_ z) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
case neg
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
hβΒΉ : Β¬i < j
hβ : Β¬i = j
β’ Var.substFun (str_fun_to_var_fun Ο) (bound_ (i - 1)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
β’ Var.substFun (str_fun_to_var_fun Ο) (if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
case pos c1 =>
simp only [Var.substFun]
simp only [Var.open]
simp only [if_pos c1]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : i < j
β’ Var.substFun (str_fun_to_var_fun Ο) (bound_ i) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : i < j
β’ Var.substFun (str_fun_to_var_fun Ο) (bound_ i) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
case pos c1 c2 =>
simp only [Var.substFun]
simp only [str_fun_to_var_fun]
simp only [Var.open]
simp only [if_neg c1]
simp only [if_pos c2]
simp only [h1]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ Var.substFun (str_fun_to_var_fun Ο) (free_ z) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ Var.substFun (str_fun_to_var_fun Ο) (free_ z) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
case neg c1 c2 =>
simp only [Var.substFun]
simp only [Var.open]
simp only [if_neg c1]
simp only [if_neg c2]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ Var.substFun (str_fun_to_var_fun Ο) (bound_ (i - 1)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ Var.substFun (str_fun_to_var_fun Ο) (bound_ (i - 1)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [Var.substFun]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : i < j
β’ Var.substFun (str_fun_to_var_fun Ο) (bound_ i) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : i < j
β’ bound_ i = Var.open j (free_ z) (bound_ i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : i < j
β’ Var.substFun (str_fun_to_var_fun Ο) (bound_ i) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [Var.open]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : i < j
β’ bound_ i = Var.open j (free_ z) (bound_ i)
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : i < j
β’ bound_ i = if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : i < j
β’ bound_ i = Var.open j (free_ z) (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [if_pos c1]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : i < j
β’ bound_ i = if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : i < j
β’ bound_ i = if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [Var.substFun]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ Var.substFun (str_fun_to_var_fun Ο) (free_ z) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ str_fun_to_var_fun Ο (free_ z) = Var.open j (free_ z) (bound_ i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ Var.substFun (str_fun_to_var_fun Ο) (free_ z) = Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [str_fun_to_var_fun]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ str_fun_to_var_fun Ο (free_ z) = Var.open j (free_ z) (bound_ i)
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = Var.open j (free_ z) (bound_ i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ str_fun_to_var_fun Ο (free_ z) = Var.open j (free_ z) (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [Var.open]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = Var.open j (free_ z) (bound_ i)
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = Var.open j (free_ z) (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [if_neg c1]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = if i = j then free_ z else bound_ (i - 1)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [if_pos c2]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = if i = j then free_ z else bound_ (i - 1)
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = free_ z
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = if i = j then free_ z else bound_ (i - 1)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [h1]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = free_ z
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : i = j
β’ free_ (Ο z) = free_ z
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [Var.substFun]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ Var.substFun (str_fun_to_var_fun Ο) (bound_ (i - 1)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ bound_ (i - 1) = Var.open j (free_ z) (bound_ i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ Var.substFun (str_fun_to_var_fun Ο) (bound_ (i - 1)) =
Var.open j (free_ z) (Var.substFun (str_fun_to_var_fun Ο) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [Var.open]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ bound_ (i - 1) = Var.open j (free_ z) (bound_ i)
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ bound_ (i - 1) = if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ bound_ (i - 1) = Var.open j (free_ z) (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [if_neg c1]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ bound_ (i - 1) = if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ bound_ (i - 1) = if i = j then free_ z else bound_ (i - 1)
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ bound_ (i - 1) = if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.SubOpenVar
|
[611, 1]
|
[647, 28]
|
simp only [if_neg c2]
|
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ bound_ (i - 1) = if i = j then free_ z else bound_ (i - 1)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ο : String β String
j : β
z : String
h1 : Ο z = z
i : β
c1 : Β¬i < j
c2 : Β¬i = j
β’ bound_ (i - 1) = if i = j then free_ z else bound_ (i - 1)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
funext v
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ shift D (V β Var.openList j (List.map free_ zs)) d = shift D V d β Var.openList (j + 1) (List.map free_ zs)
|
case h
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
v : Var
β’ shift D (V β Var.openList j (List.map free_ zs)) d v = (shift D V d β Var.openList (j + 1) (List.map free_ zs)) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ shift D (V β Var.openList j (List.map free_ zs)) d = shift D V d β Var.openList (j + 1) (List.map free_ zs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
simp
|
case h
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
v : Var
β’ shift D (V β Var.openList j (List.map free_ zs)) d v = (shift D V d β Var.openList (j + 1) (List.map free_ zs)) v
|
case h
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
v : Var
β’ shift D (V β Var.openList j (List.map free_ zs)) d v = shift D V d (Var.openList (j + 1) (List.map free_ zs) v)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
v : Var
β’ shift D (V β Var.openList j (List.map free_ zs)) d v = (shift D V d β Var.openList (j + 1) (List.map free_ zs)) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
cases v
|
case h
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
v : Var
β’ shift D (V β Var.openList j (List.map free_ zs)) d v = shift D V d (Var.openList (j + 1) (List.map free_ zs) v)
|
case h.free_
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
aβ : String
β’ shift D (V β Var.openList j (List.map free_ zs)) d (free_ aβ) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (free_ aβ))
case h.bound_
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
aβ : β
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ aβ) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ aβ))
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
v : Var
β’ shift D (V β Var.openList j (List.map free_ zs)) d v = shift D V d (Var.openList (j + 1) (List.map free_ zs) v)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
case _ x =>
simp only [Var.openList]
simp only [shift]
simp
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ shift D (V β Var.openList j (List.map free_ zs)) d (free_ x) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (free_ x))
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ V (Var.openList j (List.map free_ zs) (free_ x)) = V (free_ x)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ shift D (V β Var.openList j (List.map free_ zs)) d (free_ x) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (free_ x))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
case _ i =>
cases i
case zero =>
simp only [shift]
simp only [Var.openList]
simp
case succ i =>
simp only [shift]
simp only [Var.openList]
simp
split
case _ c1 =>
have s1 : i + 1 < j + 1
linarith
simp only [if_pos s1]
case _ c1 =>
have s1 : Β¬ i + 1 < j + 1
linarith
simp only [if_neg s1]
split
case _ c2 =>
simp
case _ c2 =>
simp
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ i) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ i))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ i) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
simp only [Var.openList]
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ shift D (V β Var.openList j (List.map free_ zs)) d (free_ x) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (free_ x))
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ shift D (V β Var.openList j (List.map free_ zs)) d (free_ x) = shift D V d (free_ x)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ shift D (V β Var.openList j (List.map free_ zs)) d (free_ x) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (free_ x))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
simp only [shift]
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ shift D (V β Var.openList j (List.map free_ zs)) d (free_ x) = shift D V d (free_ x)
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ (V β Var.openList j (List.map free_ zs)) (free_ x) = V (free_ x)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ shift D (V β Var.openList j (List.map free_ zs)) d (free_ x) = shift D V d (free_ x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
simp
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ (V β Var.openList j (List.map free_ zs)) (free_ x) = V (free_ x)
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ V (Var.openList j (List.map free_ zs) (free_ x)) = V (free_ x)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
x : String
β’ (V β Var.openList j (List.map free_ zs)) (free_ x) = V (free_ x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
cases i
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ i) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ i))
|
case zero
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ 0) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ 0))
case succ
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
nβ : β
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ (nβ + 1)) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ (nβ + 1)))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ i) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ i))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
case zero =>
simp only [shift]
simp only [Var.openList]
simp
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ 0) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ 0))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ 0) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ 0))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
case succ i =>
simp only [shift]
simp only [Var.openList]
simp
split
case _ c1 =>
have s1 : i + 1 < j + 1
linarith
simp only [if_pos s1]
case _ c1 =>
have s1 : Β¬ i + 1 < j + 1
linarith
simp only [if_neg s1]
split
case _ c2 =>
simp
case _ c2 =>
simp
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ (i + 1)) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ (i + 1)))
|
case h_3
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
iβ : β
heqβ :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ iβ.succ
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = V (bound_ iβ)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ (i + 1)) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ (i + 1)))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
simp only [shift]
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ 0) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ 0))
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ d =
match Var.openList (j + 1) (List.map free_ zs) (bound_ 0) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ 0) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ 0))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
simp only [Var.openList]
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ d =
match Var.openList (j + 1) (List.map free_ zs) (bound_ 0) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ d =
match
if 0 < j + 1 then bound_ 0
else
if x : 0 - (j + 1) < (List.map free_ zs).length then (List.map free_ zs)[0 - (j + 1)]
else bound_ (0 - (j + 1) - (List.map free_ zs).length + (j + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ d =
match Var.openList (j + 1) (List.map free_ zs) (bound_ 0) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
simp
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ d =
match
if 0 < j + 1 then bound_ 0
else
if x : 0 - (j + 1) < (List.map free_ zs).length then (List.map free_ zs)[0 - (j + 1)]
else bound_ (0 - (j + 1) - (List.map free_ zs).length + (j + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
β’ d =
match
if 0 < j + 1 then bound_ 0
else
if x : 0 - (j + 1) < (List.map free_ zs).length then (List.map free_ zs)[0 - (j + 1)]
else bound_ (0 - (j + 1) - (List.map free_ zs).length + (j + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
simp only [shift]
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ (i + 1)) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ (i + 1)))
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ (V β Var.openList j (List.map free_ zs)) (bound_ i) =
match Var.openList (j + 1) (List.map free_ zs) (bound_ (i + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ shift D (V β Var.openList j (List.map free_ zs)) d (bound_ (i + 1)) =
shift D V d (Var.openList (j + 1) (List.map free_ zs) (bound_ (i + 1)))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
simp only [Var.openList]
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ (V β Var.openList j (List.map free_ zs)) (bound_ i) =
match Var.openList (j + 1) (List.map free_ zs) (bound_ (i + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ (V β Var.openList j (List.map free_ zs)) (bound_ i) =
match
if i + 1 < j + 1 then bound_ (i + 1)
else
if x : i + 1 - (j + 1) < (List.map free_ zs).length then (List.map free_ zs)[i + 1 - (j + 1)]
else bound_ (i + 1 - (j + 1) - (List.map free_ zs).length + (j + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ (V β Var.openList j (List.map free_ zs)) (bound_ i) =
match Var.openList (j + 1) (List.map free_ zs) (bound_ (i + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
simp
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ (V β Var.openList j (List.map free_ zs)) (bound_ i) =
match
if i + 1 < j + 1 then bound_ (i + 1)
else
if x : i + 1 - (j + 1) < (List.map free_ zs).length then (List.map free_ zs)[i + 1 - (j + 1)]
else bound_ (i + 1 - (j + 1) - (List.map free_ zs).length + (j + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) =
match
if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ (V β Var.openList j (List.map free_ zs)) (bound_ i) =
match
if i + 1 < j + 1 then bound_ (i + 1)
else
if x : i + 1 - (j + 1) < (List.map free_ zs).length then (List.map free_ zs)[i + 1 - (j + 1)]
else bound_ (i + 1 - (j + 1) - (List.map free_ zs).length + (j + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
split
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) =
match
if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
|
case h_1
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβΒΉ : Var
xβ : String
heqβ :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
free_ xβ
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = V (free_ xβ)
case h_2
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
heqβ :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ 0
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = d
case h_3
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
iβ : β
heqβ :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ iβ.succ
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = V (bound_ iβ)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) =
match
if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1)) with
| free_ x => V (free_ x)
| bound_ 0 => d
| bound_ i.succ => V (bound_ i)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
case _ c1 =>
have s1 : i + 1 < j + 1
linarith
simp only [if_pos s1]
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβΒΉ : Var
xβ : String
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
free_ xβ
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = V (free_ xβ)
|
case s1
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβΒΉ : Var
xβ : String
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
free_ xβ
β’ i + 1 < j + 1
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβΒΉ : Var
xβ : String
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
free_ xβ
s1 : i + 1 < j + 1
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = V (free_ xβ)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβΒΉ : Var
xβ : String
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
free_ xβ
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = V (free_ xβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
case _ c1 =>
have s1 : Β¬ i + 1 < j + 1
linarith
simp only [if_neg s1]
split
case _ c2 =>
simp
case _ c2 =>
simp
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ 0
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = d
|
case s1
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ 0
β’ Β¬i + 1 < j + 1
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ 0
s1 : Β¬i + 1 < j + 1
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = d
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ 0
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = d
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
have s1 : i + 1 < j + 1
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβΒΉ : Var
xβ : String
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
free_ xβ
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = V (free_ xβ)
|
case s1
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβΒΉ : Var
xβ : String
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
free_ xβ
β’ i + 1 < j + 1
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβΒΉ : Var
xβ : String
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
free_ xβ
s1 : i + 1 < j + 1
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = V (free_ xβ)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβΒΉ : Var
xβ : String
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
free_ xβ
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = V (free_ xβ)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.ShiftVarOpenList
|
[815, 1]
|
[854, 17]
|
have s1 : Β¬ i + 1 < j + 1
|
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ 0
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = d
|
case s1
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ 0
β’ Β¬i + 1 < j + 1
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ 0
s1 : Β¬i + 1 < j + 1
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = d
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
V : VarAssignment D
j : β
zs : List String
d : D
i : β
xβ : Var
c1 :
(if i < j then bound_ (i + 1)
else if h : i - j < zs.length then free_ (zs.get β¨i - j, β―β©) else bound_ (i - j - zs.length + (j + 1))) =
bound_ 0
β’ V (Var.openList j (List.map free_ zs) (bound_ i)) = d
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
induction F generalizing V j
|
D : Type
I : Interpretation D
V : VarAssignment D
j : β
zs : List String
F : Formula
β’ Holds D I (V β Var.openList j (List.map free_ zs)) F β Holds D I V (Formula.openList j (List.map free_ zs) F)
|
case pred_
D : Type
I : Interpretation D
zs : List String
aβΒΉ : String
aβ : List Var
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (pred_ aβΒΉ aβ) β
Holds D I V (Formula.openList j (List.map free_ zs) (pred_ aβΒΉ aβ))
case not_
D : Type
I : Interpretation D
zs : List String
aβ : Formula
a_ihβ :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) aβ β Holds D I V (Formula.openList j (List.map free_ zs) aβ)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) aβ.not_ β
Holds D I V (Formula.openList j (List.map free_ zs) aβ.not_)
case imp_
D : Type
I : Interpretation D
zs : List String
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) aβΒΉ β Holds D I V (Formula.openList j (List.map free_ zs) aβΒΉ)
a_ihβ :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) aβ β Holds D I V (Formula.openList j (List.map free_ zs) aβ)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (aβΒΉ.imp_ aβ) β
Holds D I V (Formula.openList j (List.map free_ zs) (aβΒΉ.imp_ aβ))
case forall_
D : Type
I : Interpretation D
zs : List String
aβΒΉ : String
aβ : Formula
a_ihβ :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) aβ β Holds D I V (Formula.openList j (List.map free_ zs) aβ)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (forall_ aβΒΉ aβ) β
Holds D I V (Formula.openList j (List.map free_ zs) (forall_ aβΒΉ aβ))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V : VarAssignment D
j : β
zs : List String
F : Formula
β’ Holds D I (V β Var.openList j (List.map free_ zs)) F β Holds D I V (Formula.openList j (List.map free_ zs) F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
case pred_ X vs =>
simp only [Holds]
congr! 1
simp
|
D : Type
I : Interpretation D
zs : List String
X : String
vs : List Var
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (pred_ X vs) β
Holds D I V (Formula.openList j (List.map free_ zs) (pred_ X vs))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
X : String
vs : List Var
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (pred_ X vs) β
Holds D I V (Formula.openList j (List.map free_ zs) (pred_ X vs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
case not_ phi phi_ih =>
simp only [Holds]
congr! 1
apply phi_ih
|
D : Type
I : Interpretation D
zs : List String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi.not_ β
Holds D I V (Formula.openList j (List.map free_ zs) phi.not_)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi.not_ β
Holds D I V (Formula.openList j (List.map free_ zs) phi.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
case forall_ _ phi phi_ih =>
simp only [Holds]
apply forall_congr'
intro d
simp only [β phi_ih]
congr!
apply ShiftVarOpenList
|
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (forall_ aβ phi) β
Holds D I V (Formula.openList j (List.map free_ zs) (forall_ aβ phi))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (forall_ aβ phi) β
Holds D I V (Formula.openList j (List.map free_ zs) (forall_ aβ phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
simp only [Holds]
|
D : Type
I : Interpretation D
zs : List String
X : String
vs : List Var
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (pred_ X vs) β
Holds D I V (Formula.openList j (List.map free_ zs) (pred_ X vs))
|
D : Type
I : Interpretation D
zs : List String
X : String
vs : List Var
V : VarAssignment D
j : β
β’ I.pred_ X (List.map (V β Var.openList j (List.map free_ zs)) vs) β
I.pred_ X (List.map V (List.map (Var.openList j (List.map free_ zs)) vs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
X : String
vs : List Var
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (pred_ X vs) β
Holds D I V (Formula.openList j (List.map free_ zs) (pred_ X vs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
congr! 1
|
D : Type
I : Interpretation D
zs : List String
X : String
vs : List Var
V : VarAssignment D
j : β
β’ I.pred_ X (List.map (V β Var.openList j (List.map free_ zs)) vs) β
I.pred_ X (List.map V (List.map (Var.openList j (List.map free_ zs)) vs))
|
case a.h.e'_4
D : Type
I : Interpretation D
zs : List String
X : String
vs : List Var
V : VarAssignment D
j : β
β’ List.map (V β Var.openList j (List.map free_ zs)) vs = List.map V (List.map (Var.openList j (List.map free_ zs)) vs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
X : String
vs : List Var
V : VarAssignment D
j : β
β’ I.pred_ X (List.map (V β Var.openList j (List.map free_ zs)) vs) β
I.pred_ X (List.map V (List.map (Var.openList j (List.map free_ zs)) vs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
simp
|
case a.h.e'_4
D : Type
I : Interpretation D
zs : List String
X : String
vs : List Var
V : VarAssignment D
j : β
β’ List.map (V β Var.openList j (List.map free_ zs)) vs = List.map V (List.map (Var.openList j (List.map free_ zs)) vs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_4
D : Type
I : Interpretation D
zs : List String
X : String
vs : List Var
V : VarAssignment D
j : β
β’ List.map (V β Var.openList j (List.map free_ zs)) vs = List.map V (List.map (Var.openList j (List.map free_ zs)) vs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
simp only [Holds]
|
D : Type
I : Interpretation D
zs : List String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi.not_ β
Holds D I V (Formula.openList j (List.map free_ zs) phi.not_)
|
D : Type
I : Interpretation D
zs : List String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Β¬Holds D I (V β Var.openList j (List.map free_ zs)) phi β Β¬Holds D I V (Formula.openList j (List.map free_ zs) phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi.not_ β
Holds D I V (Formula.openList j (List.map free_ zs) phi.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
congr! 1
|
D : Type
I : Interpretation D
zs : List String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Β¬Holds D I (V β Var.openList j (List.map free_ zs)) phi β Β¬Holds D I V (Formula.openList j (List.map free_ zs) phi)
|
case a.h.e'_1.a
D : Type
I : Interpretation D
zs : List String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Β¬Holds D I (V β Var.openList j (List.map free_ zs)) phi β Β¬Holds D I V (Formula.openList j (List.map free_ zs) phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
apply phi_ih
|
case a.h.e'_1.a
D : Type
I : Interpretation D
zs : List String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) 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
zs : List String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
simp only [Holds]
|
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (phi.imp_ psi) β
Holds D I V (Formula.openList j (List.map free_ zs) (phi.imp_ psi))
|
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I (V β Var.openList j (List.map free_ zs)) psi β
Holds D I V (Formula.openList j (List.map free_ zs) phi) β Holds D I V (Formula.openList j (List.map free_ zs) psi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (phi.imp_ psi) β
Holds D I V (Formula.openList j (List.map free_ zs) (phi.imp_ psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
congr! 1
|
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I (V β Var.openList j (List.map free_ zs)) psi β
Holds D I V (Formula.openList j (List.map free_ zs) phi) β Holds D I V (Formula.openList j (List.map free_ zs) psi)
|
case a.h.a
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
case a.h'.a
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
aβ : Holds D I V (Formula.openList j (List.map free_ zs) phi)
β’ Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I (V β Var.openList j (List.map free_ zs)) psi β
Holds D I V (Formula.openList j (List.map free_ zs) phi) β Holds D I V (Formula.openList j (List.map free_ zs) psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
apply phi_ih
|
case a.h.a
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.a
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
apply psi_ih
|
case a.h'.a
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
aβ : Holds D I V (Formula.openList j (List.map free_ zs) phi)
β’ Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h'.a
D : Type
I : Interpretation D
zs : List String
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
psi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
V : VarAssignment D
j : β
aβ : Holds D I V (Formula.openList j (List.map free_ zs) phi)
β’ Holds D I (V β Var.openList j (List.map free_ zs)) psi β Holds D I V (Formula.openList j (List.map free_ zs) psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
simp only [Holds]
|
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (forall_ aβ phi) β
Holds D I V (Formula.openList j (List.map free_ zs) (forall_ aβ phi))
|
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ (β (d : D), Holds D I (shift D (V β Var.openList j (List.map free_ zs)) d) phi) β
β (d : D), Holds D I (shift D V d) (Formula.openList (j + 1) (List.map free_ zs) phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ Holds D I (V β Var.openList j (List.map free_ zs)) (forall_ aβ phi) β
Holds D I V (Formula.openList j (List.map free_ zs) (forall_ aβ phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
apply forall_congr'
|
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ (β (d : D), Holds D I (shift D (V β Var.openList j (List.map free_ zs)) d) phi) β
β (d : D), Holds D I (shift D V d) (Formula.openList (j + 1) (List.map free_ zs) phi)
|
case h
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ β (a : D),
Holds D I (shift D (V β Var.openList j (List.map free_ zs)) a) phi β
Holds D I (shift D V a) (Formula.openList (j + 1) (List.map free_ zs) phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ (β (d : D), Holds D I (shift D (V β Var.openList j (List.map free_ zs)) d) phi) β
β (d : D), Holds D I (shift D V d) (Formula.openList (j + 1) (List.map free_ zs) phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
intro d
|
case h
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ β (a : D),
Holds D I (shift D (V β Var.openList j (List.map free_ zs)) a) phi β
Holds D I (shift D V a) (Formula.openList (j + 1) (List.map free_ zs) phi)
|
case h
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
d : D
β’ Holds D I (shift D (V β Var.openList j (List.map free_ zs)) d) phi β
Holds D I (shift D V d) (Formula.openList (j + 1) (List.map free_ zs) phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
β’ β (a : D),
Holds D I (shift D (V β Var.openList j (List.map free_ zs)) a) phi β
Holds D I (shift D V a) (Formula.openList (j + 1) (List.map free_ zs) phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
simp only [β phi_ih]
|
case h
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
d : D
β’ Holds D I (shift D (V β Var.openList j (List.map free_ zs)) d) phi β
Holds D I (shift D V d) (Formula.openList (j + 1) (List.map free_ zs) phi)
|
case h
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
d : D
β’ Holds D I (shift D (V β Var.openList j (List.map free_ zs)) d) phi β
Holds D I (shift D V d β Var.openList (j + 1) (List.map free_ zs)) phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
d : D
β’ Holds D I (shift D (V β Var.openList j (List.map free_ zs)) d) phi β
Holds D I (shift D V d) (Formula.openList (j + 1) (List.map free_ zs) phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
congr!
|
case h
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
d : D
β’ Holds D I (shift D (V β Var.openList j (List.map free_ zs)) d) phi β
Holds D I (shift D V d β Var.openList (j + 1) (List.map free_ zs)) phi
|
case h.a.h.e'_3
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
d : D
β’ shift D (V β Var.openList j (List.map free_ zs)) d = shift D V d β Var.openList (j + 1) (List.map free_ zs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
d : D
β’ Holds D I (shift D (V β Var.openList j (List.map free_ zs)) d) phi β
Holds D I (shift D V d β Var.openList (j + 1) (List.map free_ zs)) phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.HoldsOpenList
|
[857, 1]
|
[887, 27]
|
apply ShiftVarOpenList
|
case h.a.h.e'_3
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
d : D
β’ shift D (V β Var.openList j (List.map free_ zs)) d = shift D V d β Var.openList (j + 1) (List.map free_ zs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.a.h.e'_3
D : Type
I : Interpretation D
zs : List String
aβ : String
phi : Formula
phi_ih :
β (V : VarAssignment D) (j : β),
Holds D I (V β Var.openList j (List.map free_ zs)) phi β Holds D I V (Formula.openList j (List.map free_ zs) phi)
V : VarAssignment D
j : β
d : D
β’ shift D (V β Var.openList j (List.map free_ zs)) d = shift D V d β Var.openList (j + 1) (List.map free_ zs)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.