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/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
split_ifs
|
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
⊢ (if X = hd.name ∧ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else Holds D I V tl (def_ X xs)) ↔
if X = hd.name ∧ xs.length = hd.args.length then
Holds D I' (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else Holds D I' V tl (def_ X xs)
|
case pos
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
h✝ : X = hd.name ∧ xs.length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔
Holds D I' (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
case neg
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
h✝ : ¬(X = hd.name ∧ xs.length = hd.args.length)
⊢ Holds D I V tl (def_ X xs) ↔ Holds D I' V tl (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
⊢ (if X = hd.name ∧ xs.length = hd.args.length then Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else Holds D I V tl (def_ X xs)) ↔
if X = hd.name ∧ xs.length = hd.args.length then
Holds D I' (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else Holds D I' V tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
case pos c1 =>
apply ih
intro P ds a1
simp only [predVarOccursIn_iff_mem_predVarSet P ds.length] at a1
simp only [hd.h2] at a1
simp at a1
|
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔
Holds D I' (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔
Holds D I' (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
case neg c1 =>
apply ih
intro P ds a1
simp only [predVarOccursIn] at a1
|
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : ¬(X = hd.name ∧ xs.length = hd.args.length)
⊢ Holds D I V tl (def_ X xs) ↔ Holds D I' V tl (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : ¬(X = hd.name ∧ xs.length = hd.args.length)
⊢ Holds D I V tl (def_ X xs) ↔ Holds D I' V tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
apply ih
|
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔
Holds D I' (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length hd.q → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q ↔
Holds D I' (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
intro P ds a1
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length hd.q → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
P : PredName
ds : List D
a1 : predVarOccursIn P ds.length hd.q
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length hd.q → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
simp only [predVarOccursIn_iff_mem_predVarSet P ds.length] at a1
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
P : PredName
ds : List D
a1 : predVarOccursIn P ds.length hd.q
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
P : PredName
ds : List D
a1 : (P, ds.length) ∈ hd.q.predVarSet
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
P : PredName
ds : List D
a1 : predVarOccursIn P ds.length hd.q
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
simp only [hd.h2] at a1
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
P : PredName
ds : List D
a1 : (P, ds.length) ∈ hd.q.predVarSet
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
P : PredName
ds : List D
a1 : (P, ds.length) ∈ ∅
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
P : PredName
ds : List D
a1 : (P, ds.length) ∈ hd.q.predVarSet
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
simp at a1
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
P : PredName
ds : List D
a1 : (P, ds.length) ∈ ∅
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : X = hd.name ∧ xs.length = hd.args.length
P : PredName
ds : List D
a1 : (P, ds.length) ∈ ∅
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
apply ih
|
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : ¬(X = hd.name ∧ xs.length = hd.args.length)
⊢ Holds D I V tl (def_ X xs) ↔ Holds D I' V tl (def_ X xs)
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : ¬(X = hd.name ∧ xs.length = hd.args.length)
⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length (def_ X xs) → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : ¬(X = hd.name ∧ xs.length = hd.args.length)
⊢ Holds D I V tl (def_ X xs) ↔ Holds D I' V tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
intro P ds a1
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : ¬(X = hd.name ∧ xs.length = hd.args.length)
⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length (def_ X xs) → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : ¬(X = hd.name ∧ xs.length = hd.args.length)
P : PredName
ds : List D
a1 : predVarOccursIn P ds.length (def_ X xs)
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : ¬(X = hd.name ∧ xs.length = hd.args.length)
⊢ ∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length (def_ X xs) → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_PredVar
|
[175, 1]
|
[236, 40]
|
simp only [predVarOccursIn] at a1
|
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : ¬(X = hd.name ∧ xs.length = hd.args.length)
P : PredName
ds : List D
a1 : predVarOccursIn P ds.length (def_ X xs)
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I I' : Interpretation D
h1 : I.pred_const_ = I'.pred_const_
hd : Definition
tl : List Definition
ih :
∀ (V : VarAssignment D) (F : Formula),
(∀ (P : PredName) (ds : List D), predVarOccursIn P ds.length F → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)) →
(Holds D I V tl F ↔ Holds D I' V tl F)
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∀ (P : PredName) (ds : List D), False → (I.pred_var_ P ds ↔ I'.pred_var_ P ds)
c1 : ¬(X = hd.name ∧ xs.length = hd.args.length)
P : PredName
ds : List D
a1 : predVarOccursIn P ds.length (def_ X xs)
⊢ I.pred_var_ P ds ↔ I'.pred_var_ P ds
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
induction F generalizing V
|
D : Type
I : Interpretation D
V : VarAssignment D
E E' : Env
F : Formula
h1 : ∃ E1, E' = E1 ++ E
h2 : all_def_in_env E F
h3 : E'.nodup_
⊢ Holds D I V E' F ↔ Holds D I V E F
|
case pred_const_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : PredName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (pred_const_ a✝¹ a✝)
⊢ Holds D I V E' (pred_const_ a✝¹ a✝) ↔ Holds D I V E (pred_const_ a✝¹ a✝)
case pred_var_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : PredName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (pred_var_ a✝¹ a✝)
⊢ Holds D I V E' (pred_var_ a✝¹ a✝) ↔ Holds D I V E (pred_var_ a✝¹ a✝)
case eq_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : VarName
V : VarAssignment D
h2 : all_def_in_env E (eq_ a✝¹ a✝)
⊢ Holds D I V E' (eq_ a✝¹ a✝) ↔ Holds D I V E (eq_ a✝¹ a✝)
case true_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
V : VarAssignment D
h2 : all_def_in_env E true_
⊢ Holds D I V E' true_ ↔ Holds D I V E true_
case false_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
V : VarAssignment D
h2 : all_def_in_env E false_
⊢ Holds D I V E' false_ ↔ Holds D I V E false_
case not_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝.not_
⊢ Holds D I V E' a✝.not_ ↔ Holds D I V E a✝.not_
case imp_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.imp_ a✝)
⊢ Holds D I V E' (a✝¹.imp_ a✝) ↔ Holds D I V E (a✝¹.imp_ a✝)
case and_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.and_ a✝)
⊢ Holds D I V E' (a✝¹.and_ a✝) ↔ Holds D I V E (a✝¹.and_ a✝)
case or_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.or_ a✝)
⊢ Holds D I V E' (a✝¹.or_ a✝) ↔ Holds D I V E (a✝¹.or_ a✝)
case iff_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.iff_ a✝)
⊢ Holds D I V E' (a✝¹.iff_ a✝) ↔ Holds D I V E (a✝¹.iff_ a✝)
case forall_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (forall_ a✝¹ a✝)
⊢ Holds D I V E' (forall_ a✝¹ a✝) ↔ Holds D I V E (forall_ a✝¹ a✝)
case exists_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (exists_ a✝¹ a✝)
⊢ Holds D I V E' (exists_ a✝¹ a✝) ↔ Holds D I V E (exists_ a✝¹ a✝)
case def_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : DefName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ a✝¹ a✝)
⊢ Holds D I V E' (def_ a✝¹ a✝) ↔ Holds D I V E (def_ a✝¹ a✝)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V : VarAssignment D
E E' : Env
F : Formula
h1 : ∃ E1, E' = E1 ++ E
h2 : all_def_in_env E F
h3 : E'.nodup_
⊢ Holds D I V E' F ↔ Holds D I V E F
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
any_goals
simp only [all_def_in_env] at h2
simp only [Holds]
|
case pred_const_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : PredName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (pred_const_ a✝¹ a✝)
⊢ Holds D I V E' (pred_const_ a✝¹ a✝) ↔ Holds D I V E (pred_const_ a✝¹ a✝)
case pred_var_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : PredName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (pred_var_ a✝¹ a✝)
⊢ Holds D I V E' (pred_var_ a✝¹ a✝) ↔ Holds D I V E (pred_var_ a✝¹ a✝)
case eq_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : VarName
V : VarAssignment D
h2 : all_def_in_env E (eq_ a✝¹ a✝)
⊢ Holds D I V E' (eq_ a✝¹ a✝) ↔ Holds D I V E (eq_ a✝¹ a✝)
case true_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
V : VarAssignment D
h2 : all_def_in_env E true_
⊢ Holds D I V E' true_ ↔ Holds D I V E true_
case false_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
V : VarAssignment D
h2 : all_def_in_env E false_
⊢ Holds D I V E' false_ ↔ Holds D I V E false_
case not_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝.not_
⊢ Holds D I V E' a✝.not_ ↔ Holds D I V E a✝.not_
case imp_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.imp_ a✝)
⊢ Holds D I V E' (a✝¹.imp_ a✝) ↔ Holds D I V E (a✝¹.imp_ a✝)
case and_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.and_ a✝)
⊢ Holds D I V E' (a✝¹.and_ a✝) ↔ Holds D I V E (a✝¹.and_ a✝)
case or_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.or_ a✝)
⊢ Holds D I V E' (a✝¹.or_ a✝) ↔ Holds D I V E (a✝¹.or_ a✝)
case iff_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.iff_ a✝)
⊢ Holds D I V E' (a✝¹.iff_ a✝) ↔ Holds D I V E (a✝¹.iff_ a✝)
case forall_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (forall_ a✝¹ a✝)
⊢ Holds D I V E' (forall_ a✝¹ a✝) ↔ Holds D I V E (forall_ a✝¹ a✝)
case exists_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (exists_ a✝¹ a✝)
⊢ Holds D I V E' (exists_ a✝¹ a✝) ↔ Holds D I V E (exists_ a✝¹ a✝)
case def_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : DefName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ a✝¹ a✝)
⊢ Holds D I V E' (def_ a✝¹ a✝) ↔ Holds D I V E (def_ a✝¹ a✝)
|
case not_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝
⊢ ¬Holds D I V E' a✝ ↔ ¬Holds D I V E a✝
case imp_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝¹ ∧ all_def_in_env E a✝
⊢ Holds D I V E' a✝¹ → Holds D I V E' a✝ ↔ Holds D I V E a✝¹ → Holds D I V E a✝
case and_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝¹ ∧ all_def_in_env E a✝
⊢ Holds D I V E' a✝¹ ∧ Holds D I V E' a✝ ↔ Holds D I V E a✝¹ ∧ Holds D I V E a✝
case or_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝¹ ∧ all_def_in_env E a✝
⊢ Holds D I V E' a✝¹ ∨ Holds D I V E' a✝ ↔ Holds D I V E a✝¹ ∨ Holds D I V E a✝
case iff_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝¹ ∧ all_def_in_env E a✝
⊢ (Holds D I V E' a✝¹ ↔ Holds D I V E' a✝) ↔ (Holds D I V E a✝¹ ↔ Holds D I V E a✝)
case forall_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝
⊢ (∀ (d : D), Holds D I (Function.updateITE V a✝¹ d) E' a✝) ↔ ∀ (d : D), Holds D I (Function.updateITE V a✝¹ d) E a✝
case exists_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝
⊢ (∃ d, Holds D I (Function.updateITE V a✝¹ d) E' a✝) ↔ ∃ d, Holds D I (Function.updateITE V a✝¹ d) E a✝
case def_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : DefName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ a✝¹ a✝)
⊢ Holds D I V E' (def_ a✝¹ a✝) ↔ Holds D I V E (def_ a✝¹ a✝)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pred_const_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : PredName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (pred_const_ a✝¹ a✝)
⊢ Holds D I V E' (pred_const_ a✝¹ a✝) ↔ Holds D I V E (pred_const_ a✝¹ a✝)
case pred_var_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : PredName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (pred_var_ a✝¹ a✝)
⊢ Holds D I V E' (pred_var_ a✝¹ a✝) ↔ Holds D I V E (pred_var_ a✝¹ a✝)
case eq_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : VarName
V : VarAssignment D
h2 : all_def_in_env E (eq_ a✝¹ a✝)
⊢ Holds D I V E' (eq_ a✝¹ a✝) ↔ Holds D I V E (eq_ a✝¹ a✝)
case true_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
V : VarAssignment D
h2 : all_def_in_env E true_
⊢ Holds D I V E' true_ ↔ Holds D I V E true_
case false_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
V : VarAssignment D
h2 : all_def_in_env E false_
⊢ Holds D I V E' false_ ↔ Holds D I V E false_
case not_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝.not_
⊢ Holds D I V E' a✝.not_ ↔ Holds D I V E a✝.not_
case imp_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.imp_ a✝)
⊢ Holds D I V E' (a✝¹.imp_ a✝) ↔ Holds D I V E (a✝¹.imp_ a✝)
case and_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.and_ a✝)
⊢ Holds D I V E' (a✝¹.and_ a✝) ↔ Holds D I V E (a✝¹.and_ a✝)
case or_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.or_ a✝)
⊢ Holds D I V E' (a✝¹.or_ a✝) ↔ Holds D I V E (a✝¹.or_ a✝)
case iff_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (V : VarAssignment D), all_def_in_env E a✝¹ → (Holds D I V E' a✝¹ ↔ Holds D I V E a✝¹)
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (a✝¹.iff_ a✝)
⊢ Holds D I V E' (a✝¹.iff_ a✝) ↔ Holds D I V E (a✝¹.iff_ a✝)
case forall_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (forall_ a✝¹ a✝)
⊢ Holds D I V E' (forall_ a✝¹ a✝) ↔ Holds D I V E (forall_ a✝¹ a✝)
case exists_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E (exists_ a✝¹ a✝)
⊢ Holds D I V E' (exists_ a✝¹ a✝) ↔ Holds D I V E (exists_ a✝¹ a✝)
case def_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : DefName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ a✝¹ a✝)
⊢ Holds D I V E' (def_ a✝¹ a✝) ↔ Holds D I V E (def_ a✝¹ a✝)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
case not_ phi phi_ih =>
congr! 1
exact phi_ih V h2
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ ¬Holds D I V E' phi ↔ ¬Holds D I V E phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ ¬Holds D I V E' phi ↔ ¬Holds D I V E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
case forall_ x phi phi_ih | exists_ x phi phi_ih =>
first | apply forall_congr' | apply exists_congr
intro d
apply phi_ih
exact h2
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ (∃ d, Holds D I (Function.updateITE V x d) E' phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ (∃ d, Holds D I (Function.updateITE V x d) E' phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
simp only [all_def_in_env] at h2
|
case def_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : DefName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ a✝¹ a✝)
⊢ Holds D I V E' (def_ a✝¹ a✝) ↔ Holds D I V E (def_ a✝¹ a✝)
|
case def_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : DefName
a✝ : List VarName
V : VarAssignment D
h2 : ∃ d ∈ E, a✝¹ = d.name ∧ a✝.length = d.args.length
⊢ Holds D I V E' (def_ a✝¹ a✝) ↔ Holds D I V E (def_ a✝¹ a✝)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case def_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : DefName
a✝ : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ a✝¹ a✝)
⊢ Holds D I V E' (def_ a✝¹ a✝) ↔ Holds D I V E (def_ a✝¹ a✝)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
simp only [Holds]
|
case exists_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝
⊢ Holds D I V E' (exists_ a✝¹ a✝) ↔ Holds D I V E (exists_ a✝¹ a✝)
|
case exists_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝
⊢ (∃ d, Holds D I (Function.updateITE V a✝¹ d) E' a✝) ↔ ∃ d, Holds D I (Function.updateITE V a✝¹ d) E a✝
|
Please generate a tactic in lean4 to solve the state.
STATE:
case exists_
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (V : VarAssignment D), all_def_in_env E a✝ → (Holds D I V E' a✝ ↔ Holds D I V E a✝)
V : VarAssignment D
h2 : all_def_in_env E a✝
⊢ Holds D I V E' (exists_ a✝¹ a✝) ↔ Holds D I V E (exists_ a✝¹ a✝)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
congr! 1
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ ¬Holds D I V E' phi ↔ ¬Holds D I V E phi
|
case a.h.e'_1.a
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ Holds D I V E' phi ↔ Holds D I V E phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ ¬Holds D I V E' phi ↔ ¬Holds D I V E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
exact phi_ih V h2
|
case a.h.e'_1.a
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ Holds D I V E' phi ↔ Holds D I V E phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_1.a
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ Holds D I V E' phi ↔ Holds D I V E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
cases h2
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
h2 : all_def_in_env E phi ∧ all_def_in_env E psi
⊢ (Holds D I V E' phi ↔ Holds D I V E' psi) ↔ (Holds D I V E phi ↔ Holds D I V E psi)
|
case intro
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
left✝ : all_def_in_env E phi
right✝ : all_def_in_env E psi
⊢ (Holds D I V E' phi ↔ Holds D I V E' psi) ↔ (Holds D I V E phi ↔ Holds D I V E psi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
h2 : all_def_in_env E phi ∧ all_def_in_env E psi
⊢ (Holds D I V E' phi ↔ Holds D I V E' psi) ↔ (Holds D I V E phi ↔ Holds D I V E psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
congr! 1
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
h2_left : all_def_in_env E phi
h2_right : all_def_in_env E psi
⊢ (Holds D I V E' phi ↔ Holds D I V E' psi) ↔ (Holds D I V E phi ↔ Holds D I V E psi)
|
case a.h.e'_1.a
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
h2_left : all_def_in_env E phi
h2_right : all_def_in_env E psi
⊢ Holds D I V E' phi ↔ Holds D I V E phi
case a.h.e'_2.a
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
h2_left : all_def_in_env E phi
h2_right : all_def_in_env E psi
⊢ Holds D I V E' psi ↔ Holds D I V E psi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
h2_left : all_def_in_env E phi
h2_right : all_def_in_env E psi
⊢ (Holds D I V E' phi ↔ Holds D I V E' psi) ↔ (Holds D I V E phi ↔ Holds D I V E psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
exact phi_ih V h2_left
|
case a.h.e'_1.a
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
h2_left : all_def_in_env E phi
h2_right : all_def_in_env E psi
⊢ Holds D I V E' phi ↔ Holds D I V E phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_1.a
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
h2_left : all_def_in_env E phi
h2_right : all_def_in_env E psi
⊢ Holds D I V E' phi ↔ Holds D I V E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
exact psi_ih V h2_right
|
case a.h.e'_2.a
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
h2_left : all_def_in_env E phi
h2_right : all_def_in_env E psi
⊢ Holds D I V E' psi ↔ Holds D I V E psi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_2.a
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
phi psi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
psi_ih : ∀ (V : VarAssignment D), all_def_in_env E psi → (Holds D I V E' psi ↔ Holds D I V E psi)
V : VarAssignment D
h2_left : all_def_in_env E phi
h2_right : all_def_in_env E psi
⊢ Holds D I V E' psi ↔ Holds D I V E psi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
first | apply forall_congr' | apply exists_congr
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ (∃ d, Holds D I (Function.updateITE V x d) E' phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E phi
|
case h
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ ∀ (a : D), Holds D I (Function.updateITE V x a) E' phi ↔ Holds D I (Function.updateITE V x a) E phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ (∃ d, Holds D I (Function.updateITE V x d) E' phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
intro d
|
case h
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ ∀ (a : D), Holds D I (Function.updateITE V x a) E' phi ↔ Holds D I (Function.updateITE V x a) E phi
|
case h
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
d : D
⊢ Holds D I (Function.updateITE V x d) E' phi ↔ Holds D I (Function.updateITE V x d) E phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ ∀ (a : D), Holds D I (Function.updateITE V x a) E' phi ↔ Holds D I (Function.updateITE V x a) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
apply phi_ih
|
case h
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
d : D
⊢ Holds D I (Function.updateITE V x d) E' phi ↔ Holds D I (Function.updateITE V x d) E phi
|
case h.h2
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
d : D
⊢ all_def_in_env E phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
d : D
⊢ Holds D I (Function.updateITE V x d) E' phi ↔ Holds D I (Function.updateITE V x d) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
exact h2
|
case h.h2
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
d : D
⊢ all_def_in_env E phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h2
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
d : D
⊢ all_def_in_env E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
apply forall_congr'
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ (∀ (d : D), Holds D I (Function.updateITE V x d) E' phi) ↔ ∀ (d : D), Holds D I (Function.updateITE V x d) E phi
|
case h
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ ∀ (a : D), Holds D I (Function.updateITE V x a) E' phi ↔ Holds D I (Function.updateITE V x a) E phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ (∀ (d : D), Holds D I (Function.updateITE V x d) E' phi) ↔ ∀ (d : D), Holds D I (Function.updateITE V x d) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
apply exists_congr
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ (∃ d, Holds D I (Function.updateITE V x d) E' phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E phi
|
case h
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ ∀ (a : D), Holds D I (Function.updateITE V x a) E' phi ↔ Holds D I (Function.updateITE V x a) E phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D), all_def_in_env E phi → (Holds D I V E' phi ↔ Holds D I V E phi)
V : VarAssignment D
h2 : all_def_in_env E phi
⊢ (∃ d, Holds D I (Function.updateITE V x d) E' phi) ↔ ∃ d, Holds D I (Function.updateITE V x d) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
apply Exists.elim h1
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
⊢ ∀ (a : Env), E' = a ++ E → (Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
intro E1 h1_1
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
⊢ ∀ (a : Env), E' = a ++ E → (Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs))
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
E1 : Env
h1_1 : E' = E1 ++ E
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
⊢ ∀ (a : Env), E' = a ++ E → (Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
clear h1
|
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
E1 : Env
h1_1 : E' = E1 ++ E
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
E1 : Env
h1_1 : E' = E1 ++ E
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h1 : ∃ E1, E' = E1 ++ E
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
E1 : Env
h1_1 : E' = E1 ++ E
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
simp only [all_def_in_env] at h2
|
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
E1 : Env
h1_1 : E' = E1 ++ E
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∃ d ∈ E, X = d.name ∧ xs.length = d.args.length
E1 : Env
h1_1 : E' = E1 ++ E
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : all_def_in_env E (def_ X xs)
E1 : Env
h1_1 : E' = E1 ++ E
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
apply Exists.elim h2
|
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∃ d ∈ E, X = d.name ∧ xs.length = d.args.length
E1 : Env
h1_1 : E' = E1 ++ E
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∃ d ∈ E, X = d.name ∧ xs.length = d.args.length
E1 : Env
h1_1 : E' = E1 ++ E
⊢ ∀ (a : Definition),
a ∈ E ∧ X = a.name ∧ xs.length = a.args.length → (Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∃ d ∈ E, X = d.name ∧ xs.length = d.args.length
E1 : Env
h1_1 : E' = E1 ++ E
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
intro a h2_1
|
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∃ d ∈ E, X = d.name ∧ xs.length = d.args.length
E1 : Env
h1_1 : E' = E1 ++ E
⊢ ∀ (a : Definition),
a ∈ E ∧ X = a.name ∧ xs.length = a.args.length → (Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs))
|
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∃ d ∈ E, X = d.name ∧ xs.length = d.args.length
E1 : Env
h1_1 : E' = E1 ++ E
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∃ d ∈ E, X = d.name ∧ xs.length = d.args.length
E1 : Env
h1_1 : E' = E1 ++ E
⊢ ∀ (a : Definition),
a ∈ E ∧ X = a.name ∧ xs.length = a.args.length → (Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
clear h2
|
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∃ d ∈ E, X = d.name ∧ xs.length = d.args.length
E1 : Env
h1_1 : E' = E1 ++ E
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
E1 : Env
h1_1 : E' = E1 ++ E
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
h2 : ∃ d ∈ E, X = d.name ∧ xs.length = d.args.length
E1 : Env
h1_1 : E' = E1 ++ E
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
simp only [Env.nodup_] at h3
|
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
E1 : Env
h1_1 : E' = E1 ++ E
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E E' : Env
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) E'
X : DefName
xs : List VarName
V : VarAssignment D
E1 : Env
h1_1 : E' = E1 ++ E
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h3 : E'.nodup_
X : DefName
xs : List VarName
V : VarAssignment D
E1 : Env
h1_1 : E' = E1 ++ E
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
subst h1_1
|
D : Type
I : Interpretation D
E E' : Env
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) E'
X : DefName
xs : List VarName
V : VarAssignment D
E1 : Env
h1_1 : E' = E1 ++ E
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
E1 : Env
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1 ++ E)
⊢ Holds D I V (E1 ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E E' : Env
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) E'
X : DefName
xs : List VarName
V : VarAssignment D
E1 : Env
h1_1 : E' = E1 ++ E
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V E' (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
induction E1
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
E1 : Env
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1 ++ E)
⊢ Holds D I V (E1 ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
case nil
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) ([] ++ E)
⊢ Holds D I V ([] ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
case cons
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (tail✝ ++ E) →
(Holds D I V (tail✝ ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (head✝ :: tail✝ ++ E)
⊢ Holds D I V (head✝ :: tail✝ ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
E1 : Env
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1 ++ E)
⊢ Holds D I V (E1 ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
case nil =>
simp
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) ([] ++ E)
⊢ Holds D I V ([] ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) ([] ++ E)
⊢ Holds D I V ([] ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
simp
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) ([] ++ E)
⊢ Holds D I V ([] ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) ([] ++ E)
⊢ Holds D I V ([] ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
simp at h3
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_hd :: E1_tl ++ E)
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 :
(∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length) ∧
List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 : List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_hd :: E1_tl ++ E)
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
cases h2_1
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 :
(∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length) ∧
List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
case intro
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 :
(∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length) ∧
List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
left✝ : a ∈ E
right✝ : X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a : Definition
h2_1 : a ∈ E ∧ X = a.name ∧ xs.length = a.args.length
E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 :
(∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length) ∧
List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
cases h2_1_right
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 :
(∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length) ∧
List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
h2_1_left : a ∈ E
h2_1_right : X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
case intro
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 :
(∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length) ∧
List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
h2_1_left : a ∈ E
left✝ : X = a.name
right✝ : xs.length = a.args.length
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 :
(∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length) ∧
List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
h2_1_left : a ∈ E
h2_1_right : X = a.name ∧ xs.length = a.args.length
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
cases h3
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 :
(∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length) ∧
List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
case intro
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
left✝ : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
right✝ : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h3 :
(∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length) ∧
List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
simp
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ Holds D I V (E1_hd :: (E1_tl ++ E)) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ Holds D I V (E1_hd :: E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
simp only [Holds]
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ Holds D I V (E1_hd :: (E1_tl ++ E)) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ (if X = E1_hd.name ∧ xs.length = E1_hd.args.length then
Holds D I (Function.updateListITE V E1_hd.args (List.map V xs)) (E1_tl ++ E) E1_hd.q
else Holds D I V (E1_tl ++ E) (def_ X xs)) ↔
Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ Holds D I V (E1_hd :: (E1_tl ++ E)) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
split_ifs
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ (if X = E1_hd.name ∧ xs.length = E1_hd.args.length then
Holds D I (Function.updateListITE V E1_hd.args (List.map V xs)) (E1_tl ++ E) E1_hd.q
else Holds D I V (E1_tl ++ E) (def_ X xs)) ↔
Holds D I V E (def_ X xs)
|
case pos
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
h✝ : X = E1_hd.name ∧ xs.length = E1_hd.args.length
⊢ Holds D I (Function.updateListITE V E1_hd.args (List.map V xs)) (E1_tl ++ E) E1_hd.q ↔ Holds D I V E (def_ X xs)
case neg
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
h✝ : ¬(X = E1_hd.name ∧ xs.length = E1_hd.args.length)
⊢ Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
⊢ (if X = E1_hd.name ∧ xs.length = E1_hd.args.length then
Holds D I (Function.updateListITE V E1_hd.args (List.map V xs)) (E1_tl ++ E) E1_hd.q
else Holds D I V (E1_tl ++ E) (def_ X xs)) ↔
Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
case _ c1 =>
exact E1_ih h3_right
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1 : ¬(X = E1_hd.name ∧ xs.length = E1_hd.args.length)
⊢ Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1 : ¬(X = E1_hd.name ∧ xs.length = E1_hd.args.length)
⊢ Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
cases c1
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1 : X = E1_hd.name ∧ xs.length = E1_hd.args.length
⊢ Holds D I (Function.updateListITE V E1_hd.args (List.map V xs)) (E1_tl ++ E) E1_hd.q ↔ Holds D I V E (def_ X xs)
|
case intro
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
left✝ : X = E1_hd.name
right✝ : xs.length = E1_hd.args.length
⊢ Holds D I (Function.updateListITE V E1_hd.args (List.map V xs)) (E1_tl ++ E) E1_hd.q ↔ Holds D I V E (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1 : X = E1_hd.name ∧ xs.length = E1_hd.args.length
⊢ Holds D I (Function.updateListITE V E1_hd.args (List.map V xs)) (E1_tl ++ E) E1_hd.q ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
exfalso
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ Holds D I (Function.updateListITE V E1_hd.args (List.map V xs)) (E1_tl ++ E) E1_hd.q ↔ Holds D I V E (def_ X xs)
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ Holds D I (Function.updateListITE V E1_hd.args (List.map V xs)) (E1_tl ++ E) E1_hd.q ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
apply h3_left a
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ False
|
case a
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ a ∈ E1_tl ∨ a ∈ E
case a
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ E1_hd.name = a.name
case a
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ E1_hd.args.length = a.args.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
right
|
case a
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ a ∈ E1_tl ∨ a ∈ E
|
case a.h
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ a ∈ E
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ a ∈ E1_tl ∨ a ∈ E
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
exact h2_1_left
|
case a.h
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ a ∈ E
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ a ∈ E
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
subst c1_left
|
case a
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ E1_hd.name = a.name
|
case a
D : Type
I : Interpretation D
E : Env
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
h2_1_left : a ∈ E
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_right : xs.length = E1_hd.args.length
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ E1_hd.name xs) ↔ Holds D I V E (def_ E1_hd.name xs))
h2_1_right_left : E1_hd.name = a.name
⊢ E1_hd.name = a.name
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ E1_hd.name = a.name
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
exact h2_1_right_left
|
case a
D : Type
I : Interpretation D
E : Env
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
h2_1_left : a ∈ E
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_right : xs.length = E1_hd.args.length
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ E1_hd.name xs) ↔ Holds D I V E (def_ E1_hd.name xs))
h2_1_right_left : E1_hd.name = a.name
⊢ E1_hd.name = a.name
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a
D : Type
I : Interpretation D
E : Env
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
h2_1_left : a ∈ E
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_right : xs.length = E1_hd.args.length
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ E1_hd.name xs) ↔ Holds D I V E (def_ E1_hd.name xs))
h2_1_right_left : E1_hd.name = a.name
⊢ E1_hd.name = a.name
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
trans List.length xs
|
case a
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ E1_hd.args.length = a.args.length
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ E1_hd.args.length = xs.length
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ xs.length = a.args.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ E1_hd.args.length = a.args.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
simp only [eq_comm]
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ E1_hd.args.length = xs.length
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ xs.length = E1_hd.args.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ E1_hd.args.length = xs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
exact c1_right
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ xs.length = E1_hd.args.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ xs.length = E1_hd.args.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
exact h2_1_right_right
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ xs.length = a.args.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1_left : X = E1_hd.name
c1_right : xs.length = E1_hd.args.length
⊢ xs.length = a.args.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Semantics.lean
|
FOL.NV.Holds_coincide_Env
|
[239, 1]
|
[316, 35]
|
exact E1_ih h3_right
|
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1 : ¬(X = E1_hd.name ∧ xs.length = E1_hd.args.length)
⊢ Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
X : DefName
xs : List VarName
V : VarAssignment D
a E1_hd : Definition
E1_tl : List Definition
E1_ih :
List.Pairwise (fun d1 d2 => d1.name = d2.name → d1.args.length = d2.args.length → False) (E1_tl ++ E) →
(Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs))
h2_1_left : a ∈ E
h2_1_right_left : X = a.name
h2_1_right_right : xs.length = a.args.length
h3_left : ∀ (a' : Definition), a' ∈ E1_tl ∨ a' ∈ E → E1_hd.name = a'.name → ¬E1_hd.args.length = a'.args.length
h3_right : List.Pairwise (fun d1 d2 => d1.name = d2.name → ¬d1.args.length = d2.args.length) (E1_tl ++ E)
c1 : ¬(X = E1_hd.name ∧ xs.length = E1_hd.args.length)
⊢ Holds D I V (E1_tl ++ E) (def_ X xs) ↔ Holds D I V E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
induction E generalizing F V
|
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
u v : VarName
F : Formula
a : D
h1 : ¬isFreeIn v F
h2 : ¬isBoundIn v F
⊢ Holds D I (Function.updateITE V u a) E F ↔
Holds D I (Function.updateITE V v a) E (Sub.Var.One.Rec.fastReplaceFree u v F)
|
case nil
D : Type
I : Interpretation D
u v : VarName
a : D
V : VarAssignment D
F : Formula
h1 : ¬isFreeIn v F
h2 : ¬isBoundIn v F
⊢ Holds D I (Function.updateITE V u a) [] F ↔
Holds D I (Function.updateITE V v a) [] (Sub.Var.One.Rec.fastReplaceFree u v F)
case cons
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
F : Formula
h1 : ¬isFreeIn v F
h2 : ¬isBoundIn v F
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) F ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v F)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
u v : VarName
F : Formula
a : D
h1 : ¬isFreeIn v F
h2 : ¬isBoundIn v F
⊢ Holds D I (Function.updateITE V u a) E F ↔
Holds D I (Function.updateITE V v a) E (Sub.Var.One.Rec.fastReplaceFree u v F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
case nil.def_ X xs =>
simp only [Sub.Var.One.Rec.fastReplaceFree]
simp only [Holds]
|
D : Type
I : Interpretation D
u v : VarName
a : D
X : DefName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (def_ X xs)
h2 : ¬isBoundIn v (def_ X xs)
⊢ Holds D I (Function.updateITE V u a) [] (def_ X xs) ↔
Holds D I (Function.updateITE V v a) [] (Sub.Var.One.Rec.fastReplaceFree u v (def_ X xs))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
X : DefName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (def_ X xs)
h2 : ¬isBoundIn v (def_ X xs)
⊢ Holds D I (Function.updateITE V u a) [] (def_ X xs) ↔
Holds D I (Function.updateITE V v a) [] (Sub.Var.One.Rec.fastReplaceFree u v (def_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
induction F generalizing V
|
case cons
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
F : Formula
h1 : ¬isFreeIn v F
h2 : ¬isBoundIn v F
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) F ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v F)
|
case cons.pred_const_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝¹ : PredName
a✝ : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (pred_const_ a✝¹ a✝)
h2 : ¬isBoundIn v (pred_const_ a✝¹ a✝)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_const_ a✝¹ a✝) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_const_ a✝¹ a✝))
case cons.pred_var_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝¹ : PredName
a✝ : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (pred_var_ a✝¹ a✝)
h2 : ¬isBoundIn v (pred_var_ a✝¹ a✝)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ a✝¹ a✝) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ a✝¹ a✝))
case cons.eq_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝¹ a✝ : VarName
V : VarAssignment D
h1 : ¬isFreeIn v (eq_ a✝¹ a✝)
h2 : ¬isBoundIn v (eq_ a✝¹ a✝)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (eq_ a✝¹ a✝) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (eq_ a✝¹ a✝))
case cons.true_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
h1 : ¬isFreeIn v true_
h2 : ¬isBoundIn v true_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) true_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v true_)
case cons.false_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
h1 : ¬isFreeIn v false_
h2 : ¬isBoundIn v false_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) false_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v false_)
case cons.not_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝ : Formula
a_ih✝ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝ →
¬isBoundIn v a✝ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝))
V : VarAssignment D
h1 : ¬isFreeIn v a✝.not_
h2 : ¬isBoundIn v a✝.not_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝.not_)
case cons.imp_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝¹ a✝ : Formula
a_ih✝¹ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝¹ →
¬isBoundIn v a✝¹ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝¹ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝¹))
a_ih✝ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝ →
¬isBoundIn v a✝ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝))
V : VarAssignment D
h1 : ¬isFreeIn v (a✝¹.imp_ a✝)
h2 : ¬isBoundIn v (a✝¹.imp_ a✝)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (a✝¹.imp_ a✝) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (a✝¹.imp_ a✝))
case cons.and_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝¹ a✝ : Formula
a_ih✝¹ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝¹ →
¬isBoundIn v a✝¹ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝¹ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝¹))
a_ih✝ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝ →
¬isBoundIn v a✝ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝))
V : VarAssignment D
h1 : ¬isFreeIn v (a✝¹.and_ a✝)
h2 : ¬isBoundIn v (a✝¹.and_ a✝)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (a✝¹.and_ a✝) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (a✝¹.and_ a✝))
case cons.or_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝¹ a✝ : Formula
a_ih✝¹ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝¹ →
¬isBoundIn v a✝¹ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝¹ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝¹))
a_ih✝ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝ →
¬isBoundIn v a✝ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝))
V : VarAssignment D
h1 : ¬isFreeIn v (a✝¹.or_ a✝)
h2 : ¬isBoundIn v (a✝¹.or_ a✝)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (a✝¹.or_ a✝) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (a✝¹.or_ a✝))
case cons.iff_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝¹ a✝ : Formula
a_ih✝¹ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝¹ →
¬isBoundIn v a✝¹ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝¹ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝¹))
a_ih✝ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝ →
¬isBoundIn v a✝ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝))
V : VarAssignment D
h1 : ¬isFreeIn v (a✝¹.iff_ a✝)
h2 : ¬isBoundIn v (a✝¹.iff_ a✝)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (a✝¹.iff_ a✝) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (a✝¹.iff_ a✝))
case cons.forall_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝¹ : VarName
a✝ : Formula
a_ih✝ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝ →
¬isBoundIn v a✝ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝))
V : VarAssignment D
h1 : ¬isFreeIn v (forall_ a✝¹ a✝)
h2 : ¬isBoundIn v (forall_ a✝¹ a✝)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (forall_ a✝¹ a✝) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (forall_ a✝¹ a✝))
case cons.exists_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝¹ : VarName
a✝ : Formula
a_ih✝ :
∀ (V : VarAssignment D),
¬isFreeIn v a✝ →
¬isBoundIn v a✝ →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) a✝ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v a✝))
V : VarAssignment D
h1 : ¬isFreeIn v (exists_ a✝¹ a✝)
h2 : ¬isBoundIn v (exists_ a✝¹ a✝)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (exists_ a✝¹ a✝) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (exists_ a✝¹ a✝))
case cons.def_
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
a✝¹ : DefName
a✝ : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (def_ a✝¹ a✝)
h2 : ¬isBoundIn v (def_ a✝¹ a✝)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (def_ a✝¹ a✝) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (def_ a✝¹ a✝))
|
Please generate a tactic in lean4 to solve the state.
STATE:
case cons
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
F : Formula
h1 : ¬isFreeIn v F
h2 : ¬isBoundIn v F
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) F ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
case pred_const_ X xs | pred_var_ X xs =>
simp only [isFreeIn] at h1
simp only [Sub.Var.One.Rec.fastReplaceFree]
simp only [Holds]
congr! 1
simp
simp only [List.map_eq_map_iff]
intro x a1
simp
simp only [Function.updateITE]
simp only [eq_comm]
split_ifs
case _ c1 c2 =>
rfl
case _ c1 c2 =>
contradiction
case _ c1 c2 =>
subst c2
contradiction
case _ c1 c2 =>
rfl
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (pred_var_ X xs)
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (pred_var_ X xs)
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
case true_ | false_ =>
simp only [Sub.Var.One.Rec.fastReplaceFree]
simp only [Holds]
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
h1 : ¬isFreeIn v false_
h2 : ¬isBoundIn v false_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) false_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v false_)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
h1 : ¬isFreeIn v false_
h2 : ¬isBoundIn v false_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) false_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v false_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
case not_ phi phi_ih =>
simp only [isFreeIn] at h1
simp only [isBoundIn] at h2
simp only [Sub.Var.One.Rec.fastReplaceFree]
simp only [Holds]
congr! 1
exact phi_ih V h1 h2
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi.not_
h2 : ¬isBoundIn v phi.not_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi.not_
h2 : ¬isBoundIn v phi.not_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [isFreeIn] at h1
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (pred_var_ X xs)
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (pred_var_ X xs)
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [Sub.Var.One.Rec.fastReplaceFree]
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (pred_var_ X (List.map (fun x => if u = x then v else x) xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [Holds]
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (pred_var_ X (List.map (fun x => if u = x then v else x) xs))
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ I.pred_var_ X (List.map (Function.updateITE V u a) xs) ↔
I.pred_var_ X (List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (pred_var_ X (List.map (fun x => if u = x then v else x) xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
congr! 1
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ I.pred_var_ X (List.map (Function.updateITE V u a) xs) ↔
I.pred_var_ X (List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs))
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ List.map (Function.updateITE V u a) xs =
List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ I.pred_var_ X (List.map (Function.updateITE V u a) xs) ↔
I.pred_var_ X (List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ List.map (Function.updateITE V u a) xs =
List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs)
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ List.map (Function.updateITE V u a) xs = List.map (Function.updateITE V v a ∘ fun x => if u = x then v else x) xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ List.map (Function.updateITE V u a) xs =
List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [List.map_eq_map_iff]
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ List.map (Function.updateITE V u a) xs = List.map (Function.updateITE V v a ∘ fun x => if u = x then v else x) xs
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ ∀ x ∈ xs, Function.updateITE V u a x = (Function.updateITE V v a ∘ fun x => if u = x then v else x) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ List.map (Function.updateITE V u a) xs = List.map (Function.updateITE V v a ∘ fun x => if u = x then v else x) xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
intro x a1
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ ∀ x ∈ xs, Function.updateITE V u a x = (Function.updateITE V v a ∘ fun x => if u = x then v else x) x
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ Function.updateITE V u a x = (Function.updateITE V v a ∘ fun x => if u = x then v else x) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ ∀ x ∈ xs, Function.updateITE V u a x = (Function.updateITE V v a ∘ fun x => if u = x then v else x) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ Function.updateITE V u a x = (Function.updateITE V v a ∘ fun x => if u = x then v else x) x
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ Function.updateITE V u a x = Function.updateITE V v a (if u = x then v else x)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ Function.updateITE V u a x = (Function.updateITE V v a ∘ fun x => if u = x then v else x) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [Function.updateITE]
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ Function.updateITE V u a x = Function.updateITE V v a (if u = x then v else x)
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ (if x = u then a else V x) = if (if u = x then v else x) = v then a else V (if u = x then v else x)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ Function.updateITE V u a x = Function.updateITE V v a (if u = x then v else x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [eq_comm]
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ (if x = u then a else V x) = if (if u = x then v else x) = v then a else V (if u = x then v else x)
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ (if u = x then a else V x) = if v = if u = x then v else x then a else V (if u = x then v else x)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ (if x = u then a else V x) = if (if u = x then v else x) = v then a else V (if u = x then v else x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
split_ifs
|
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ (if u = x then a else V x) = if v = if u = x then v else x then a else V (if u = x then v else x)
|
case pos
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
h✝¹ : u = x
h✝ : v = v
⊢ a = a
case neg
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
h✝¹ : u = x
h✝ : ¬v = v
⊢ a = V v
case pos
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
h✝¹ : ¬u = x
h✝ : v = x
⊢ V x = a
case neg
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
h✝¹ : ¬u = x
h✝ : ¬v = x
⊢ V x = V x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ (if u = x then a else V x) = if v = if u = x then v else x then a else V (if u = x then v else x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
case _ c1 c2 =>
rfl
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : v = v
⊢ a = a
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : v = v
⊢ a = a
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
case _ c1 c2 =>
contradiction
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : ¬v = v
⊢ a = V v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : ¬v = v
⊢ a = V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
case _ c1 c2 =>
subst c2
contradiction
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : ¬u = x
c2 : v = x
⊢ V x = a
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : ¬u = x
c2 : v = x
⊢ V x = a
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
case _ c1 c2 =>
rfl
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : ¬u = x
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
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : ¬u = x
c2 : ¬v = x
⊢ V x = V x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
rfl
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : v = v
⊢ a = a
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : v = v
⊢ a = a
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
contradiction
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : ¬v = v
⊢ a = V v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : ¬v = v
⊢ a = V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
subst c2
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : ¬u = x
c2 : v = x
⊢ V x = a
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
a1 : v ∈ xs
c1 : ¬u = v
⊢ V v = a
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : ¬u = x
c2 : v = x
⊢ V x = a
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
contradiction
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
a1 : v ∈ xs
c1 : ¬u = v
⊢ V v = a
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
a1 : v ∈ xs
c1 : ¬u = v
⊢ V v = a
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
rfl
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : ¬u = x
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
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : ¬u = x
c2 : ¬v = x
⊢ V x = V x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [isFreeIn] at h1
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬isFreeIn v (eq_ x y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (eq_ x y) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (eq_ x y))
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (eq_ x y) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (eq_ x y))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬isFreeIn v (eq_ x y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (eq_ x y) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (eq_ x y))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [Sub.Var.One.Rec.fastReplaceFree]
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (eq_ x y) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (eq_ x y))
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (eq_ x y) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (eq_ (if u = x then v else x) (if u = y then v else y))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (eq_ x y) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (eq_ x y))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [Holds]
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (eq_ x y) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (eq_ (if u = x then v else x) (if u = y then v else y))
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Function.updateITE V u a x = Function.updateITE V u a y ↔
Function.updateITE V v a (if u = x then v else x) = Function.updateITE V v a (if u = y then v else y)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (eq_ x y) ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (eq_ (if u = x then v else x) (if u = y then v else y))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
congr! 1
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Function.updateITE V u a x = Function.updateITE V u a y ↔
Function.updateITE V v a (if u = x then v else x) = Function.updateITE V v a (if u = y then v else y)
|
case a.h.e'_2
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Function.updateITE V u a x = Function.updateITE V v a (if u = x then v else x)
case a.h.e'_3
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Function.updateITE V u a y = Function.updateITE V v a (if u = y then v else y)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Function.updateITE V u a x = Function.updateITE V u a y ↔
Function.updateITE V v a (if u = x then v else x) = Function.updateITE V v a (if u = y then v else y)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [Function.updateITE]
|
case a.h.e'_2
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Function.updateITE V u a x = Function.updateITE V v a (if u = x then v else x)
|
case a.h.e'_2
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ (if x = u then a else V x) = if (if u = x then v else x) = v then a else V (if u = x then v else x)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_2
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Function.updateITE V u a x = Function.updateITE V v a (if u = x then v else x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
split_ifs <;> tauto
|
case a.h.e'_2
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ (if x = u then a else V x) = if (if u = x then v else x) = v then a else V (if u = x then v else x)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_2
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ (if x = u then a else V x) = if (if u = x then v else x) = v then a else V (if u = x then v else x)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [Function.updateITE]
|
case a.h.e'_3
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Function.updateITE V u a y = Function.updateITE V v a (if u = y then v else y)
|
case a.h.e'_3
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ (if y = u then a else V y) = if (if u = y then v else y) = v then a else V (if u = y then v else y)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_3
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ Function.updateITE V u a y = Function.updateITE V v a (if u = y then v else y)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
split_ifs <;> tauto
|
case a.h.e'_3
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ (if y = u then a else V y) = if (if u = y then v else y) = v then a else V (if u = y then v else y)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_3
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x y : VarName
V : VarAssignment D
h1 : ¬(v = x ∨ v = y)
h2 : ¬isBoundIn v (eq_ x y)
⊢ (if y = u then a else V y) = if (if u = y then v else y) = v then a else V (if u = y then v else y)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [Sub.Var.One.Rec.fastReplaceFree]
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
h1 : ¬isFreeIn v false_
h2 : ¬isBoundIn v false_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) false_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v false_)
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
h1 : ¬isFreeIn v false_
h2 : ¬isBoundIn v false_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) false_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) false_
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
h1 : ¬isFreeIn v false_
h2 : ¬isBoundIn v false_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) false_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v false_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [Holds]
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
h1 : ¬isFreeIn v false_
h2 : ¬isBoundIn v false_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) false_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) false_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
h1 : ¬isFreeIn v false_
h2 : ¬isBoundIn v false_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) false_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) false_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [isFreeIn] at h1
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi.not_
h2 : ¬isBoundIn v phi.not_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi
h2 : ¬isBoundIn v phi.not_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi.not_
h2 : ¬isBoundIn v phi.not_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [isBoundIn] at h2
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi
h2 : ¬isBoundIn v phi.not_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi
h2 : ¬isBoundIn v phi
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi
h2 : ¬isBoundIn v phi.not_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Alpha.lean
|
FOL.NV.replace_empty_Holds
|
[181, 1]
|
[345, 19]
|
simp only [Sub.Var.One.Rec.fastReplaceFree]
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi
h2 : ¬isBoundIn v phi
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
|
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi
h2 : ¬isBoundIn v phi
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi).not_
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
∀ (V : VarAssignment D) (F : Formula),
¬isFreeIn v F →
¬isBoundIn v F →
(Holds D I (Function.updateITE V u a) tail✝ F ↔
Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
∀ (V : VarAssignment D),
¬isFreeIn v phi →
¬isBoundIn v phi →
(Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi
h2 : ¬isBoundIn v phi
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.