url
stringclasses 147
values | commit
stringclasses 147
values | file_path
stringlengths 7
101
| full_name
stringlengths 1
94
| start
stringlengths 6
10
| end
stringlengths 6
11
| tactic
stringlengths 1
11.2k
| state_before
stringlengths 3
2.09M
| state_after
stringlengths 6
2.09M
| input
stringlengths 73
2.09M
|
|---|---|---|---|---|---|---|---|---|---|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ (∃ d, Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi) ↔
Holds D I V (head✝ :: tail✝) (exists_ x (fastReplaceFree v t phi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ (∃ d, Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi) ↔
∃ d, Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ (∃ d, Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi) ↔
Holds D I V (head✝ :: tail✝) (exists_ x (fastReplaceFree v t phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
first | apply forall_congr' | apply exists_congr
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ (∃ d, Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi) ↔
∃ d, Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ ∀ (a : D),
Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x a) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ (∃ d, Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi) ↔
∃ d, Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
intro d
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ ∀ (a : D),
Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x a) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ ∀ (a : D),
Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x a) (head✝ :: tail✝) (fastReplaceFree v t phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
cases h1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
case h.inl
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h✝ : v = x
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
case h.inr
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h✝ : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
case inl h1 =>
contradiction
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : v = x
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : v = x
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
case inr h1 =>
simp only [Function.updateITE_comm V v x d (V' t) c1]
apply phi_ih (Function.updateITE V x d) (binders ∪ {x}) h1
simp only [Function.updateITE]
simp
push_neg
intros v' a1 a2
simp only [if_neg a2]
exact h2 v' a1
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
apply forall_congr'
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ (∀ (d : D), Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi) ↔
∀ (d : D), Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ ∀ (a : D),
Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x a) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ (∀ (d : D), Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi) ↔
∀ (d : D), Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
apply exists_congr
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ (∃ d, Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi) ↔
∃ d, Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ ∀ (a : D),
Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x a) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h1 : v = x ∨ fastAdmitsAux v t (binders ∪ {x}) phi
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
⊢ (∃ d, Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi) ↔
∃ d, Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
contradiction
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : v = x
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : v = x
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp only [Function.updateITE_comm V v x d (V' t) c1]
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ Holds D I (Function.updateITE (Function.updateITE V x d) v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ Holds D I (Function.updateITE (Function.updateITE V v (V' t)) x d) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
apply phi_ih (Function.updateITE V x d) (binders ∪ {x}) h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ Holds D I (Function.updateITE (Function.updateITE V x d) v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders ∪ {x}, V' v = Function.updateITE V x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ Holds D I (Function.updateITE (Function.updateITE V x d) v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V x d) (head✝ :: tail✝) (fastReplaceFree v t phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp only [Function.updateITE]
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders ∪ {x}, V' v = Function.updateITE V x d v
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders ∪ {x}, V' v = if v = x then d else V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders ∪ {x}, V' v = Function.updateITE V x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders ∪ {x}, V' v = if v = x then d else V v
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders, ¬v = x → V' v = if v = x then d else V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders ∪ {x}, V' v = if v = x then d else V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
push_neg
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders, ¬v = x → V' v = if v = x then d else V v
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders, v ≠ x → V' v = if v = x then d else V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders, ¬v = x → V' v = if v = x then d else V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
intros v' a1 a2
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders, v ≠ x → V' v = if v = x then d else V v
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
v' : VarName
a1 : v' ∉ binders
a2 : v' ≠ x
⊢ V' v' = if v' = x then d else V v'
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
⊢ ∀ v ∉ binders, v ≠ x → V' v = if v = x then d else V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp only [if_neg a2]
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
v' : VarName
a1 : v' ∉ binders
a2 : v' ≠ x
⊢ V' v' = if v' = x then d else V v'
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
v' : VarName
a1 : v' ∉ binders
a2 : v' ≠ x
⊢ V' v' = V v'
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
v' : VarName
a1 : v' ∉ binders
a2 : v' ≠ x
⊢ V' v' = if v' = x then d else V v'
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
exact h2 v' a1
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
v' : VarName
a1 : v' ∉ binders
a2 : v' ≠ x
⊢ V' v' = V v'
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tail✝ F ↔ Holds D I V tail✝ (fastReplaceFree v t F))
x : VarName
phi : Formula
phi_ih :
∀ (V : VarAssignment D) (binders : Finset VarName),
fastAdmitsAux v t binders phi →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) (head✝ :: tail✝) phi ↔
Holds D I V (head✝ :: tail✝) (fastReplaceFree v t phi))
V : VarAssignment D
binders : Finset VarName
h2 : ∀ v ∉ binders, V' v = V v
c1 : ¬v = x
d : D
h1 : fastAdmitsAux v t (binders ∪ {x}) phi
v' : VarName
a1 : v' ∉ binders
a2 : v' ≠ x
⊢ V' v' = V v'
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
unfold Function.updateITE
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
⊢ (if X = hd.name ∧ xs.length = hd.args.length then
Holds D I
(Function.updateListITE (Function.updateITE V v (V' t)) hd.args (List.map (Function.updateITE V v (V' t)) xs))
tl hd.q
else Holds D I (Function.updateITE V v (V' t)) tl (def_ X xs)) ↔
if X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length then
Holds D I (Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs))) tl hd.q
else Holds D I V tl (def_ X (List.map (fun x => if v = x then t else x) xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
⊢ (if X = hd.name ∧ xs.length = hd.args.length then
Holds D I
(Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs))
tl hd.q
else Holds D I (fun c => if c = v then V' t else V c) tl (def_ X xs)) ↔
if X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length then
Holds D I (Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs))) tl hd.q
else Holds D I V tl (def_ X (List.map (fun x => if v = x then t else x) xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
⊢ (if X = hd.name ∧ xs.length = hd.args.length then
Holds D I
(Function.updateListITE (Function.updateITE V v (V' t)) hd.args (List.map (Function.updateITE V v (V' t)) xs))
tl hd.q
else Holds D I (Function.updateITE V v (V' t)) tl (def_ X xs)) ↔
if X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length then
Holds D I (Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs))) tl hd.q
else Holds D I V tl (def_ X (List.map (fun x => if v = x then t else x) xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
congr! 1
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
⊢ (if X = hd.name ∧ xs.length = hd.args.length then
Holds D I
(Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs))
tl hd.q
else Holds D I (fun c => if c = v then V' t else V c) tl (def_ X xs)) ↔
if X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length then
Holds D I (Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs))) tl hd.q
else Holds D I V tl (def_ X (List.map (fun x => if v = x then t else x) xs))
|
case a.h₁.a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
⊢ X = hd.name ∧ xs.length = hd.args.length ↔
X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
case a.h₂.a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
⊢ Holds D I
(Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs))
tl hd.q ↔
Holds D I (Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs))) tl hd.q
case a.h₃.a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ Holds D I (fun c => if c = v then V' t else V c) tl (def_ X xs) ↔
Holds D I V tl (def_ X (List.map (fun x => if v = x then t else x) xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
⊢ (if X = hd.name ∧ xs.length = hd.args.length then
Holds D I
(Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs))
tl hd.q
else Holds D I (fun c => if c = v then V' t else V c) tl (def_ X xs)) ↔
if X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length then
Holds D I (Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs))) tl hd.q
else Holds D I V tl (def_ X (List.map (fun x => if v = x then t else x) xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
case _ =>
simp
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
⊢ X = hd.name ∧ xs.length = hd.args.length ↔
X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
⊢ X = hd.name ∧ xs.length = hd.args.length ↔
X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
⊢ X = hd.name ∧ xs.length = hd.args.length ↔
X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
⊢ X = hd.name ∧ xs.length = hd.args.length ↔
X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
apply Holds_coincide_Var
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
⊢ Holds D I
(Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs))
tl hd.q ↔
Holds D I (Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs))) tl hd.q
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
⊢ ∀ (v_1 : VarName),
isFreeIn v_1 hd.q →
Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs) v_1 =
Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs)) v_1
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
⊢ Holds D I
(Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs))
tl hd.q ↔
Holds D I (Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs))) tl hd.q
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
intro v' a1
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
⊢ ∀ (v_1 : VarName),
isFreeIn v_1 hd.q →
Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs) v_1 =
Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs)) v_1
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs)) v'
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
⊢ ∀ (v_1 : VarName),
isFreeIn v_1 hd.q →
Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs) v_1 =
Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs)) v_1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs)) v'
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map V (List.map (fun x => if v = x then t else x) xs)) v'
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp only [eq_comm]
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (fun c => if v = c then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if c = v then V' t else V c) hd.args
(List.map (fun c => if c = v then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
have s1 :
(List.map (fun (x : VarName) =>
if v = x then V' t else V x) xs) =
(List.map (V ∘ fun (x : VarName) =>
if v = x then t else x) xs)
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (fun c => if v = c then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
|
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (fun c => if v = c then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (fun c => if v = c then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
{
simp only [List.map_eq_map_iff]
intro x a2
simp
split_ifs
case _ c2 =>
apply h2
subst c2
exact h1 a2
case _ c2 =>
rfl
}
|
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (fun c => if v = c then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (fun c => if v = c then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (fun c => if v = c then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp only [s1]
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (fun c => if v = c then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (V ∘ fun x => if v = x then t else x) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (fun c => if v = c then V' t else V c) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
apply Function.updateListITE_mem_eq_len
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (V ∘ fun x => if v = x then t else x) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
|
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ v' ∈ hd.args
case h1.h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ hd.args.length = (List.map (V ∘ fun x => if v = x then t else x) xs).length
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
(List.map (V ∘ fun x => if v = x then t else x) xs) v' =
Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp only [List.map_eq_map_iff]
|
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
|
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ ∀ x ∈ xs, (if v = x then V' t else V x) = (V ∘ fun x => if v = x then t else x) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
intro x a2
|
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ ∀ x ∈ xs, (if v = x then V' t else V x) = (V ∘ fun x => if v = x then t else x) x
|
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
⊢ (if v = x then V' t else V x) = (V ∘ fun x => if v = x then t else x) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ ∀ x ∈ xs, (if v = x then V' t else V x) = (V ∘ fun x => if v = x then t else x) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp
|
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
⊢ (if v = x then V' t else V x) = (V ∘ fun x => if v = x then t else x) x
|
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
⊢ (if v = x then V' t else V x) = V (if v = x then t else x)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
⊢ (if v = x then V' t else V x) = (V ∘ fun x => if v = x then t else x) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
split_ifs
|
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
⊢ (if v = x then V' t else V x) = V (if v = x then t else x)
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
h✝ : v = x
⊢ V' t = V t
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
h✝ : ¬v = x
⊢ V x = V x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
⊢ (if v = x then V' t else V x) = V (if v = x then t else x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
case _ c2 =>
apply h2
subst c2
exact h1 a2
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ V' t = V t
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ V' t = V t
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
case _ c2 =>
rfl
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : ¬v = x
⊢ V x = V x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : ¬v = x
⊢ V x = V x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
apply h2
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ V' t = V t
|
case a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ t ∉ binders
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ V' t = V t
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
subst c2
|
case a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ t ∉ binders
|
case a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
a2 : v ∈ xs
⊢ t ∉ binders
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ t ∉ binders
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
exact h1 a2
|
case a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
a2 : v ∈ xs
⊢ t ∉ binders
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
a2 : v ∈ xs
⊢ t ∉ binders
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
rfl
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : ¬v = x
⊢ V x = V x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : ¬v = x
⊢ V x = V x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp only [isFreeIn_iff_mem_freeVarSet] at a1
|
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ v' ∈ hd.args
|
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
a1 : v' ∈ hd.q.freeVarSet
⊢ v' ∈ hd.args
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ v' ∈ hd.args
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp only [← List.mem_toFinset]
|
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
a1 : v' ∈ hd.q.freeVarSet
⊢ v' ∈ hd.args
|
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
a1 : v' ∈ hd.q.freeVarSet
⊢ v' ∈ hd.args.toFinset
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
a1 : v' ∈ hd.q.freeVarSet
⊢ v' ∈ hd.args
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
exact Finset.mem_of_subset hd.h1 a1
|
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
a1 : v' ∈ hd.q.freeVarSet
⊢ v' ∈ hd.args.toFinset
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
a1 : v' ∈ hd.q.freeVarSet
⊢ v' ∈ hd.args.toFinset
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp at c1
|
case h1.h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ hd.args.length = (List.map (V ∘ fun x => if v = x then t else x) xs).length
|
case h1.h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ hd.args.length = (List.map (V ∘ fun x => if v = x then t else x) xs).length
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ hd.args.length = (List.map (V ∘ fun x => if v = x then t else x) xs).length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp
|
case h1.h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ hd.args.length = (List.map (V ∘ fun x => if v = x then t else x) xs).length
|
case h1.h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ hd.args.length = xs.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ hd.args.length = (List.map (V ∘ fun x => if v = x then t else x) xs).length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
tauto
|
case h1.h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ hd.args.length = xs.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ hd.args.length = xs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
apply ih V binders
|
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ Holds D I (fun c => if c = v then V' t else V c) tl (def_ X xs) ↔
Holds D I V tl (def_ X (List.map (fun x => if v = x then t else x) xs))
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ fastAdmitsAux v t binders (def_ X xs)
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ ∀ v ∉ binders, V' v = V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ Holds D I (fun c => if c = v then V' t else V c) tl (def_ X xs) ↔
Holds D I V tl (def_ X (List.map (fun x => if v = x then t else x) xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
simp only [fastAdmitsAux]
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ fastAdmitsAux v t binders (def_ X xs)
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ v ∈ xs → t ∉ binders
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ fastAdmitsAux v t binders (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
exact h1
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ v ∈ xs → t ∉ binders
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ v ∈ xs → t ∉ binders
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
|
[1001, 1]
|
[1136, 17]
|
exact h2
|
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ ∀ v ∉ binders, V' v = V v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
fastAdmitsAux v t binders F →
(∀ v ∉ binders, V' v = V v) →
(Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
a✝ : ¬(X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length)
⊢ ∀ v ∉ binders, V' v = V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem
|
[1139, 1]
|
[1153, 7]
|
simp only [fastAdmits] at h1
|
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
v t : VarName
F : Formula
h1 : fastAdmits v t F
⊢ Holds D I (Function.updateITE V v (V t)) E F ↔ Holds D I V E (fastReplaceFree v t F)
|
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
v t : VarName
F : Formula
h1 : fastAdmitsAux v t ∅ F
⊢ Holds D I (Function.updateITE V v (V t)) E F ↔ Holds D I V E (fastReplaceFree v t F)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
v t : VarName
F : Formula
h1 : fastAdmits v t F
⊢ Holds D I (Function.updateITE V v (V t)) E F ↔ Holds D I V E (fastReplaceFree v t F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem
|
[1139, 1]
|
[1153, 7]
|
apply substitution_theorem_aux D I V V E v t ∅ F h1
|
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
v t : VarName
F : Formula
h1 : fastAdmitsAux v t ∅ F
⊢ Holds D I (Function.updateITE V v (V t)) E F ↔ Holds D I V E (fastReplaceFree v t F)
|
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
v t : VarName
F : Formula
h1 : fastAdmitsAux v t ∅ F
⊢ ∀ v ∉ ∅, V v = V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
v t : VarName
F : Formula
h1 : fastAdmitsAux v t ∅ F
⊢ Holds D I (Function.updateITE V v (V t)) E F ↔ Holds D I V E (fastReplaceFree v t F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_theorem
|
[1139, 1]
|
[1153, 7]
|
simp
|
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
v t : VarName
F : Formula
h1 : fastAdmitsAux v t ∅ F
⊢ ∀ v ∉ ∅, V v = V v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
v t : VarName
F : Formula
h1 : fastAdmitsAux v t ∅ F
⊢ ∀ v ∉ ∅, V v = V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_is_valid
|
[1156, 1]
|
[1168, 11]
|
simp only [IsValid] at h2
|
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : F.IsValid
⊢ (fastReplaceFree v t F).IsValid
|
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ (fastReplaceFree v t F).IsValid
|
Please generate a tactic in lean4 to solve the state.
STATE:
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : F.IsValid
⊢ (fastReplaceFree v t F).IsValid
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_is_valid
|
[1156, 1]
|
[1168, 11]
|
simp only [IsValid]
|
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ (fastReplaceFree v t F).IsValid
|
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (fastReplaceFree v t F)
|
Please generate a tactic in lean4 to solve the state.
STATE:
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ (fastReplaceFree v t F).IsValid
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_is_valid
|
[1156, 1]
|
[1168, 11]
|
intro D I V E
|
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (fastReplaceFree v t F)
|
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I V E (fastReplaceFree v t F)
|
Please generate a tactic in lean4 to solve the state.
STATE:
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (fastReplaceFree v t F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_is_valid
|
[1156, 1]
|
[1168, 11]
|
simp only [← substitution_theorem D I V E v t F h1]
|
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I V E (fastReplaceFree v t F)
|
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I (Function.updateITE V v (V t)) E F
|
Please generate a tactic in lean4 to solve the state.
STATE:
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I V E (fastReplaceFree v t F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Rec/Admits.lean
|
FOL.NV.Sub.Var.One.Rec.substitution_is_valid
|
[1156, 1]
|
[1168, 11]
|
apply h2
|
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I (Function.updateITE V v (V t)) E F
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
v t : VarName
F : Formula
h1 : fastAdmits v t F
h2 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I (Function.updateITE V v (V t)) E F
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_zero_iff_is_free
|
[171, 1]
|
[182, 9]
|
cases v
|
v : Var
⊢ Var.lc_at 0 v ↔ v.isFree
|
case free_
a✝ : String
⊢ Var.lc_at 0 (free_ a✝) ↔ (free_ a✝).isFree
case bound_
a✝ : ℕ
⊢ Var.lc_at 0 (bound_ a✝) ↔ (bound_ a✝).isFree
|
Please generate a tactic in lean4 to solve the state.
STATE:
v : Var
⊢ Var.lc_at 0 v ↔ v.isFree
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_zero_iff_is_free
|
[171, 1]
|
[182, 9]
|
case free_ x =>
simp only [Var.lc_at]
simp only [isFree]
|
x : String
⊢ Var.lc_at 0 (free_ x) ↔ (free_ x).isFree
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
x : String
⊢ Var.lc_at 0 (free_ x) ↔ (free_ x).isFree
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_zero_iff_is_free
|
[171, 1]
|
[182, 9]
|
case bound_ i =>
simp only [Var.lc_at]
simp only [isFree]
simp
|
i : ℕ
⊢ Var.lc_at 0 (bound_ i) ↔ (bound_ i).isFree
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
⊢ Var.lc_at 0 (bound_ i) ↔ (bound_ i).isFree
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_zero_iff_is_free
|
[171, 1]
|
[182, 9]
|
simp only [Var.lc_at]
|
x : String
⊢ Var.lc_at 0 (free_ x) ↔ (free_ x).isFree
|
x : String
⊢ True ↔ (free_ x).isFree
|
Please generate a tactic in lean4 to solve the state.
STATE:
x : String
⊢ Var.lc_at 0 (free_ x) ↔ (free_ x).isFree
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_zero_iff_is_free
|
[171, 1]
|
[182, 9]
|
simp only [isFree]
|
x : String
⊢ True ↔ (free_ x).isFree
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
x : String
⊢ True ↔ (free_ x).isFree
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_zero_iff_is_free
|
[171, 1]
|
[182, 9]
|
simp only [Var.lc_at]
|
i : ℕ
⊢ Var.lc_at 0 (bound_ i) ↔ (bound_ i).isFree
|
i : ℕ
⊢ i < 0 ↔ (bound_ i).isFree
|
Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
⊢ Var.lc_at 0 (bound_ i) ↔ (bound_ i).isFree
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_zero_iff_is_free
|
[171, 1]
|
[182, 9]
|
simp only [isFree]
|
i : ℕ
⊢ i < 0 ↔ (bound_ i).isFree
|
i : ℕ
⊢ i < 0 ↔ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
⊢ i < 0 ↔ (bound_ i).isFree
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.lc_at_zero_iff_is_free
|
[171, 1]
|
[182, 9]
|
simp
|
i : ℕ
⊢ i < 0 ↔ False
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
i : ℕ
⊢ i < 0 ↔ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
induction vs
|
vs : List Var
h1 : ∀ v ∈ vs, Var.lc_at 0 v
⊢ ∃ xs, vs = List.map free_ xs
|
case nil
h1 : ∀ v ∈ [], Var.lc_at 0 v
⊢ ∃ xs, [] = List.map free_ xs
case cons
head✝ : Var
tail✝ : List Var
tail_ih✝ : (∀ v ∈ tail✝, Var.lc_at 0 v) → ∃ xs, tail✝ = List.map free_ xs
h1 : ∀ v ∈ head✝ :: tail✝, Var.lc_at 0 v
⊢ ∃ xs, head✝ :: tail✝ = List.map free_ xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
vs : List Var
h1 : ∀ v ∈ vs, Var.lc_at 0 v
⊢ ∃ xs, vs = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
case nil =>
apply Exists.intro []
simp
|
h1 : ∀ v ∈ [], Var.lc_at 0 v
⊢ ∃ xs, [] = List.map free_ xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
h1 : ∀ v ∈ [], Var.lc_at 0 v
⊢ ∃ xs, [] = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
case cons hd tl ih =>
simp at h1
cases h1
case intro h1_left h1_right =>
specialize ih h1_right
apply Exists.elim ih
intro xs a1
cases hd
case free_ x =>
apply Exists.intro (x :: xs)
simp
exact a1
case bound_ i =>
simp only [Var.lc_at] at h1_left
simp at h1_left
|
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1 : ∀ v ∈ hd :: tl, Var.lc_at 0 v
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1 : ∀ v ∈ hd :: tl, Var.lc_at 0 v
⊢ ∃ xs, hd :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
apply Exists.intro []
|
h1 : ∀ v ∈ [], Var.lc_at 0 v
⊢ ∃ xs, [] = List.map free_ xs
|
h1 : ∀ v ∈ [], Var.lc_at 0 v
⊢ [] = List.map free_ []
|
Please generate a tactic in lean4 to solve the state.
STATE:
h1 : ∀ v ∈ [], Var.lc_at 0 v
⊢ ∃ xs, [] = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
simp
|
h1 : ∀ v ∈ [], Var.lc_at 0 v
⊢ [] = List.map free_ []
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
h1 : ∀ v ∈ [], Var.lc_at 0 v
⊢ [] = List.map free_ []
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
simp at h1
|
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1 : ∀ v ∈ hd :: tl, Var.lc_at 0 v
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1 : Var.lc_at 0 hd ∧ ∀ a ∈ tl, Var.lc_at 0 a
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1 : ∀ v ∈ hd :: tl, Var.lc_at 0 v
⊢ ∃ xs, hd :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
cases h1
|
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1 : Var.lc_at 0 hd ∧ ∀ a ∈ tl, Var.lc_at 0 a
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
case intro
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
left✝ : Var.lc_at 0 hd
right✝ : ∀ a ∈ tl, Var.lc_at 0 a
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1 : Var.lc_at 0 hd ∧ ∀ a ∈ tl, Var.lc_at 0 a
⊢ ∃ xs, hd :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
case intro h1_left h1_right =>
specialize ih h1_right
apply Exists.elim ih
intro xs a1
cases hd
case free_ x =>
apply Exists.intro (x :: xs)
simp
exact a1
case bound_ i =>
simp only [Var.lc_at] at h1_left
simp at h1_left
|
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
⊢ ∃ xs, hd :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
specialize ih h1_right
|
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
hd : Var
tl : List Var
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
hd : Var
tl : List Var
ih : (∀ v ∈ tl, Var.lc_at 0 v) → ∃ xs, tl = List.map free_ xs
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
⊢ ∃ xs, hd :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
apply Exists.elim ih
|
hd : Var
tl : List Var
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
hd : Var
tl : List Var
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
⊢ ∀ (a : List String), tl = List.map free_ a → ∃ xs, hd :: tl = List.map free_ xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
hd : Var
tl : List Var
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
⊢ ∃ xs, hd :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
intro xs a1
|
hd : Var
tl : List Var
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
⊢ ∀ (a : List String), tl = List.map free_ a → ∃ xs, hd :: tl = List.map free_ xs
|
hd : Var
tl : List Var
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
hd : Var
tl : List Var
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
⊢ ∀ (a : List String), tl = List.map free_ a → ∃ xs, hd :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
cases hd
|
hd : Var
tl : List Var
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
⊢ ∃ xs, hd :: tl = List.map free_ xs
|
case free_
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
a✝ : String
h1_left : Var.lc_at 0 (free_ a✝)
⊢ ∃ xs, free_ a✝ :: tl = List.map free_ xs
case bound_
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
a✝ : ℕ
h1_left : Var.lc_at 0 (bound_ a✝)
⊢ ∃ xs, bound_ a✝ :: tl = List.map free_ xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
hd : Var
tl : List Var
h1_left : Var.lc_at 0 hd
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
⊢ ∃ xs, hd :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
case free_ x =>
apply Exists.intro (x :: xs)
simp
exact a1
|
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
x : String
h1_left : Var.lc_at 0 (free_ x)
⊢ ∃ xs, free_ x :: tl = List.map free_ xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
x : String
h1_left : Var.lc_at 0 (free_ x)
⊢ ∃ xs, free_ x :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
case bound_ i =>
simp only [Var.lc_at] at h1_left
simp at h1_left
|
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
i : ℕ
h1_left : Var.lc_at 0 (bound_ i)
⊢ ∃ xs, bound_ i :: tl = List.map free_ xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
i : ℕ
h1_left : Var.lc_at 0 (bound_ i)
⊢ ∃ xs, bound_ i :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
apply Exists.intro (x :: xs)
|
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
x : String
h1_left : Var.lc_at 0 (free_ x)
⊢ ∃ xs, free_ x :: tl = List.map free_ xs
|
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
x : String
h1_left : Var.lc_at 0 (free_ x)
⊢ free_ x :: tl = List.map free_ (x :: xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
x : String
h1_left : Var.lc_at 0 (free_ x)
⊢ ∃ xs, free_ x :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
simp
|
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
x : String
h1_left : Var.lc_at 0 (free_ x)
⊢ free_ x :: tl = List.map free_ (x :: xs)
|
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
x : String
h1_left : Var.lc_at 0 (free_ x)
⊢ tl = List.map free_ xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
x : String
h1_left : Var.lc_at 0 (free_ x)
⊢ free_ x :: tl = List.map free_ (x :: xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
exact a1
|
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
x : String
h1_left : Var.lc_at 0 (free_ x)
⊢ tl = List.map free_ xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
x : String
h1_left : Var.lc_at 0 (free_ x)
⊢ tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
simp only [Var.lc_at] at h1_left
|
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
i : ℕ
h1_left : Var.lc_at 0 (bound_ i)
⊢ ∃ xs, bound_ i :: tl = List.map free_ xs
|
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
i : ℕ
h1_left : i < 0
⊢ ∃ xs, bound_ i :: tl = List.map free_ xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
i : ℕ
h1_left : Var.lc_at 0 (bound_ i)
⊢ ∃ xs, bound_ i :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.free_var_list_to_string_list
|
[186, 1]
|
[210, 24]
|
simp at h1_left
|
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
i : ℕ
h1_left : i < 0
⊢ ∃ xs, bound_ i :: tl = List.map free_ xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
tl : List Var
h1_right : ∀ a ∈ tl, Var.lc_at 0 a
ih : ∃ xs, tl = List.map free_ xs
xs : List String
a1 : tl = List.map free_ xs
i : ℕ
h1_left : i < 0
⊢ ∃ xs, bound_ i :: tl = List.map free_ xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
cases v
|
j : ℕ
z : String
v : Var
⊢ (Var.open j (free_ z) v).freeVarSet ⊆ v.freeVarSet ∪ {free_ z}
|
case free_
j : ℕ
z a✝ : String
⊢ (Var.open j (free_ z) (free_ a✝)).freeVarSet ⊆ (free_ a✝).freeVarSet ∪ {free_ z}
case bound_
j : ℕ
z : String
a✝ : ℕ
⊢ (Var.open j (free_ z) (bound_ a✝)).freeVarSet ⊆ (bound_ a✝).freeVarSet ∪ {free_ z}
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
v : Var
⊢ (Var.open j (free_ z) v).freeVarSet ⊆ v.freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
case free_ x =>
simp only [Var.open]
simp only [Var.freeVarSet]
simp
|
j : ℕ
z x : String
⊢ (Var.open j (free_ z) (free_ x)).freeVarSet ⊆ (free_ x).freeVarSet ∪ {free_ z}
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z x : String
⊢ (Var.open j (free_ z) (free_ x)).freeVarSet ⊆ (free_ x).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
case bound_ i =>
simp only [Var.open]
split_ifs
case _ c1 =>
simp only [Var.freeVarSet]
simp
case _ c1 c2 =>
simp only [Var.freeVarSet]
simp
case _ c1 c2 =>
simp only [Var.freeVarSet]
simp
|
j : ℕ
z : String
i : ℕ
⊢ (Var.open j (free_ z) (bound_ i)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
⊢ (Var.open j (free_ z) (bound_ i)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
simp only [Var.open]
|
j : ℕ
z x : String
⊢ (Var.open j (free_ z) (free_ x)).freeVarSet ⊆ (free_ x).freeVarSet ∪ {free_ z}
|
j : ℕ
z x : String
⊢ (free_ x).freeVarSet ⊆ (free_ x).freeVarSet ∪ {free_ z}
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z x : String
⊢ (Var.open j (free_ z) (free_ x)).freeVarSet ⊆ (free_ x).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
simp only [Var.freeVarSet]
|
j : ℕ
z x : String
⊢ (free_ x).freeVarSet ⊆ (free_ x).freeVarSet ∪ {free_ z}
|
j : ℕ
z x : String
⊢ {free_ x} ⊆ {free_ x} ∪ {free_ z}
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z x : String
⊢ (free_ x).freeVarSet ⊆ (free_ x).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
simp
|
j : ℕ
z x : String
⊢ {free_ x} ⊆ {free_ x} ∪ {free_ z}
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z x : String
⊢ {free_ x} ⊆ {free_ x} ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
simp only [Var.open]
|
j : ℕ
z : String
i : ℕ
⊢ (Var.open j (free_ z) (bound_ i)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
j : ℕ
z : String
i : ℕ
⊢ (if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
⊢ (Var.open j (free_ z) (bound_ i)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
split_ifs
|
j : ℕ
z : String
i : ℕ
⊢ (if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
case pos
j : ℕ
z : String
i : ℕ
h✝ : i < j
⊢ (bound_ i).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
case pos
j : ℕ
z : String
i : ℕ
h✝¹ : ¬i < j
h✝ : i = j
⊢ (free_ z).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
case neg
j : ℕ
z : String
i : ℕ
h✝¹ : ¬i < j
h✝ : ¬i = j
⊢ (bound_ (i - 1)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
⊢ (if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
case _ c1 =>
simp only [Var.freeVarSet]
simp
|
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ (bound_ i).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ (bound_ i).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
case _ c1 c2 =>
simp only [Var.freeVarSet]
simp
|
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ (free_ z).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ (free_ z).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
case _ c1 c2 =>
simp only [Var.freeVarSet]
simp
|
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : ¬i = j
⊢ (bound_ (i - 1)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : ¬i = j
⊢ (bound_ (i - 1)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
simp only [Var.freeVarSet]
|
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ (bound_ i).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ ∅ ⊆ ∅ ∪ {free_ z}
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ (bound_ i).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
simp
|
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ ∅ ⊆ ∅ ∪ {free_ z}
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ ∅ ⊆ ∅ ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
simp only [Var.freeVarSet]
|
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ (free_ z).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ {free_ z} ⊆ ∅ ∪ {free_ z}
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ (free_ z).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
simp
|
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ {free_ z} ⊆ ∅ ∪ {free_ z}
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ {free_ z} ⊆ ∅ ∪ {free_ z}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/LN/Paper.lean
|
LN.VarOpenFreeVarSet
|
[216, 1]
|
[238, 11]
|
simp only [Var.freeVarSet]
|
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : ¬i = j
⊢ (bound_ (i - 1)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
|
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : ¬i = j
⊢ ∅ ⊆ ∅ ∪ {free_ z}
|
Please generate a tactic in lean4 to solve the state.
STATE:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : ¬i = j
⊢ (bound_ (i - 1)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.