url
stringclasses 147
values | commit
stringclasses 147
values | file_path
stringlengths 7
101
| full_name
stringlengths 1
94
| start
stringlengths 6
10
| end
stringlengths 6
11
| tactic
stringlengths 1
11.2k
| state_before
stringlengths 3
2.09M
| state_after
stringlengths 6
2.09M
| input
stringlengths 73
2.09M
|
|---|---|---|---|---|---|---|---|---|---|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [phi_ih]
|
case h
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
⊢ Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet else x)
d)
E
(sub
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
c phi) ↔
Holds D I (Function.updateITE (V ∘ σ) x d) E phi
|
case h
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
⊢ Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d ∘
Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
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 : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
⊢ Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet else x)
d)
E
(sub
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
c phi) ↔
Holds D I (Function.updateITE (V ∘ σ) x d) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
apply Holds_coincide_Var
|
case h
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
⊢ Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d ∘
Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
E phi ↔
Holds D I (Function.updateITE (V ∘ σ) x d) E phi
|
case h.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
⊢ ∀ (v : VarName),
isFreeIn v phi →
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d ∘
Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
v =
Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
⊢ Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d ∘
Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
E phi ↔
Holds D I (Function.updateITE (V ∘ σ) x d) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
intro v a1
|
case h.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
⊢ ∀ (v : VarName),
isFreeIn v phi →
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d ∘
Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
v =
Function.updateITE (V ∘ σ) x d v
|
case h.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
⊢ (Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d ∘
Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
v =
Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
⊢ ∀ (v : VarName),
isFreeIn v phi →
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d ∘
Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
v =
Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp
|
case h.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
⊢ (Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d ∘
Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
v =
Function.updateITE (V ∘ σ) x d v
|
case h.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
⊢ Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet else x) d
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet else x)
v) =
Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
⊢ (Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d ∘
Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
v =
Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
split_ifs
|
case h.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
⊢ Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet else x) d
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet else x)
v) =
Function.updateITE (V ∘ σ) x d v
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
h✝ : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
⊢ Function.updateITE V (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) d
(Function.updateITE σ x (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) v) =
Function.updateITE (V ∘ σ) x d v
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
h✝ : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
⊢ Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet else x) d
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet else x)
v) =
Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
apply forall_congr'
|
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
⊢ (∀ (d : D),
Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d)
E
(sub
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
c phi)) ↔
∀ (d : D), Holds D I (Function.updateITE (V ∘ σ) x d) E phi
|
case h
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
⊢ ∀ (a : D),
Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
a)
E
(sub
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
c 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 : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
⊢ (∀ (d : D),
Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d)
E
(sub
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
c phi)) ↔
∀ (d : D), Holds D I (Function.updateITE (V ∘ σ) x d) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
apply exists_congr
|
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
⊢ (∃ d,
Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d)
E
(sub
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
c phi)) ↔
∃ d, Holds D I (Function.updateITE (V ∘ σ) x d) E phi
|
case h
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
⊢ ∀ (a : D),
Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
a)
E
(sub
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
c 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 : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
⊢ (∃ d,
Holds D I
(Function.updateITE V
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x)
d)
E
(sub
(Function.updateITE σ x
(if ∃ y ∈ phi.freeVarSet \ {x}, σ y = x then fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet
else x))
c phi)) ↔
∃ d, Holds D I (Function.updateITE (V ∘ σ) x d) E phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
obtain s0 := fresh_not_mem x c (freeVarSet (sub (Function.updateITE σ x x) c phi))
|
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
⊢ Function.updateITE V (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) d
(Function.updateITE σ x (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) v) =
Function.updateITE (V ∘ σ) x d v
|
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
s0 : fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
⊢ Function.updateITE V (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) d
(Function.updateITE σ x (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) v) =
Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
⊢ Function.updateITE V (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) d
(Function.updateITE σ x (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) v) =
Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
generalize (fresh x c (freeVarSet (sub (Function.updateITE σ x x) c phi))) = x' at *
|
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
s0 : fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
⊢ Function.updateITE V (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) d
(Function.updateITE σ x (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) v) =
Function.updateITE (V ∘ σ) x d v
|
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
s0 : fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
⊢ Function.updateITE V (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) d
(Function.updateITE σ x (fresh x c (sub (Function.updateITE σ x x) c phi).freeVarSet) v) =
Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
by_cases c2 : v = x
|
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : v = x
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [c2]
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : v = x
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : v = x
⊢ Function.updateITE V x' d (Function.updateITE σ x x' x) = Function.updateITE (V ∘ σ) x d x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : v = x
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [Function.updateITE]
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : v = x
⊢ Function.updateITE V x' d (Function.updateITE σ x x' x) = Function.updateITE (V ∘ σ) x d x
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : v = x
⊢ (if (if True then x' else σ x) = x' then d else V (if True then x' else σ x)) = if True then d else (V ∘ σ) x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : v = x
⊢ Function.updateITE V x' d (Function.updateITE σ x x' x) = Function.updateITE (V ∘ σ) x d x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : v = x
⊢ (if (if True then x' else σ x) = x' then d else V (if True then x' else σ x)) = if True then d else (V ∘ σ) x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : v = x
⊢ (if (if True then x' else σ x) = x' then d else V (if True then x' else σ x)) = if True then d else (V ∘ σ) x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
by_cases c3 : σ v = x'
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : σ v = x'
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
subst c3
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : σ v = x'
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : σ v = x'
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [freeVarSet_sub_eq_freeVarSet_image] at s0
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
have s1 : σ v ∈ Finset.image (Function.updateITE σ x x) (freeVarSet phi)
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
|
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ σ v ∈ Finset.image (Function.updateITE σ x x) phi.freeVarSet
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
s1 : σ v ∈ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
apply Finset.mem_image_update
|
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ σ v ∈ Finset.image (Function.updateITE σ x x) phi.freeVarSet
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
s1 : σ v ∈ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
|
case s1.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ ¬v = x
case s1.h2
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ v ∈ phi.freeVarSet
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
s1 : σ v ∈ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ σ v ∈ Finset.image (Function.updateITE σ x x) phi.freeVarSet
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
s1 : σ v ∈ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
contradiction
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
s1 : σ v ∈ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
s1 : σ v ∈ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ Function.updateITE V (σ v) d (Function.updateITE σ x (σ v) v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
exact c2
|
case s1.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ ¬v = x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1.h1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ ¬v = x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [← isFreeIn_iff_mem_freeVarSet]
|
case s1.h2
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ v ∈ phi.freeVarSet
|
case s1.h2
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ isFreeIn v phi
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1.h2
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ v ∈ phi.freeVarSet
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
exact a1
|
case s1.h2
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ isFreeIn v phi
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1.h2
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s0 : σ v ∉ Finset.image (Function.updateITE σ x x) phi.freeVarSet
⊢ isFreeIn v phi
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [Function.updateITE]
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ (if (if v = x then x' else σ v) = x' then d else V (if v = x then x' else σ v)) = if v = x then d else (V ∘ σ) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ Function.updateITE V x' d (Function.updateITE σ x x' v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [if_neg c2]
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ (if (if v = x then x' else σ v) = x' then d else V (if v = x then x' else σ v)) = if v = x then d else (V ∘ σ) v
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ (if σ v = x' then d else V (σ v)) = (V ∘ σ) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ (if (if v = x then x' else σ v) = x' then d else V (if v = x then x' else σ v)) = if v = x then d else (V ∘ σ) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [if_neg c3]
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ (if σ v = x' then d else V (σ v)) = (V ∘ σ) v
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ V (σ v) = (V ∘ σ) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ (if σ v = x' then d else V (σ v)) = (V ∘ σ) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ V (σ v) = (V ∘ σ) v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
x' : VarName
s0 : x' ∉ (sub (Function.updateITE σ x x) c phi).freeVarSet
c2 : ¬v = x
c3 : ¬σ v = x'
⊢ V (σ v) = (V ∘ σ) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
by_cases c2 : v = x
|
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : v = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
subst c2
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : v = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {v}, σ y = v
⊢ Function.updateITE V v d (Function.updateITE σ v v v) = Function.updateITE (V ∘ σ) v d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : v = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [Function.updateITE]
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {v}, σ y = v
⊢ Function.updateITE V v d (Function.updateITE σ v v v) = Function.updateITE (V ∘ σ) v d v
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {v}, σ y = v
⊢ (if (if True then v else σ v) = v then d else V (if True then v else σ v)) = if True then d else (V ∘ σ) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
E : Env
c : Char
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {v}, σ y = v
⊢ Function.updateITE V v d (Function.updateITE σ v v v) = Function.updateITE (V ∘ σ) v d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp
|
case pos
D : Type
I : Interpretation D
E : Env
c : Char
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {v}, σ y = v
⊢ (if (if True then v else σ v) = v then d else V (if True then v else σ v)) = if True then d else (V ∘ σ) v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
E : Env
c : Char
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {v}, σ y = v
⊢ (if (if True then v else σ v) = v then d else V (if True then v else σ v)) = if True then d else (V ∘ σ) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
have s1 : ¬ σ v = x
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
|
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
⊢ ¬σ v = x
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [Function.updateITE]
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ (if (if v = x then x else σ v) = x then d else V (if v = x then x else σ v)) = if v = x then d else (V ∘ σ) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ Function.updateITE V x d (Function.updateITE σ x x v) = Function.updateITE (V ∘ σ) x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [if_neg c2]
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ (if (if v = x then x else σ v) = x then d else V (if v = x then x else σ v)) = if v = x then d else (V ∘ σ) v
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ (if σ v = x then d else V (σ v)) = (V ∘ σ) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ (if (if v = x then x else σ v) = x then d else V (if v = x then x else σ v)) = if v = x then d else (V ∘ σ) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [if_neg s1]
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ (if σ v = x then d else V (σ v)) = (V ∘ σ) v
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ V (σ v) = (V ∘ σ) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ (if σ v = x then d else V (σ v)) = (V ∘ σ) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp
|
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ V (σ v) = (V ∘ σ) v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
s1 : ¬σ v = x
⊢ V (σ v) = (V ∘ σ) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
intro contra
|
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
⊢ ¬σ v = x
|
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
⊢ ¬σ v = x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
apply c1
|
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ False
|
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
apply Exists.intro v
|
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
|
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ v ∈ phi.freeVarSet \ {x} ∧ σ v = x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ ∃ y ∈ phi.freeVarSet \ {x}, σ y = x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
constructor
|
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ v ∈ phi.freeVarSet \ {x} ∧ σ v = x
|
case s1.left
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ v ∈ phi.freeVarSet \ {x}
case s1.right
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ σ v = x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ v ∈ phi.freeVarSet \ {x} ∧ σ v = x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp
|
case s1.left
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ v ∈ phi.freeVarSet \ {x}
|
case s1.left
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ v ∈ phi.freeVarSet ∧ ¬v = x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1.left
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ v ∈ phi.freeVarSet \ {x}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [← isFreeIn_iff_mem_freeVarSet]
|
case s1.left
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ v ∈ phi.freeVarSet ∧ ¬v = x
|
case s1.left
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ isFreeIn v phi ∧ ¬v = x
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1.left
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ v ∈ phi.freeVarSet ∧ ¬v = x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
tauto
|
case s1.left
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ isFreeIn v phi ∧ ¬v = x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1.left
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ isFreeIn v phi ∧ ¬v = x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
exact contra
|
case s1.right
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ σ v = x
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case s1.right
D : Type
I : Interpretation D
E : Env
c : Char
x : VarName
phi : Formula
phi_ih : ∀ (V : VarAssignment D) (σ : VarName → VarName), Holds D I V E (sub σ c phi) ↔ Holds D I (V ∘ σ) E phi
V : VarAssignment D
σ : VarName → VarName
d : D
v : VarName
a1 : isFreeIn v phi
c1 : ¬∃ y ∈ phi.freeVarSet \ {x}, σ y = x
c2 : ¬v = x
contra : σ v = x
⊢ σ v = x
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
induction E
|
D : Type
I : Interpretation D
E : Env
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
⊢ Holds D I V E (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) E (def_ X xs)
|
case nil
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
⊢ Holds D I V [] (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) [] (def_ X xs)
case cons
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
head✝ : Definition
tail✝ : List Definition
tail_ih✝ : Holds D I V tail✝ (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) tail✝ (def_ X xs)
⊢ Holds D I V (head✝ :: tail✝) (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) (head✝ :: tail✝) (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
E : Env
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
⊢ Holds D I V E (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) E (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
case nil =>
simp only [sub]
simp only [Holds]
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
⊢ Holds D I V [] (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) [] (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
⊢ Holds D I V [] (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) [] (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [sub]
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
⊢ Holds D I V [] (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) [] (def_ X xs)
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
⊢ Holds D I V [] (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) [] (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
⊢ Holds D I V [] (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) [] (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [Holds]
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
⊢ Holds D I V [] (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) [] (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
⊢ Holds D I V [] (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) [] (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [sub] at E_ih
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ Holds D I V (E_hd :: E_tl) (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) (E_hd :: E_tl) (def_ X xs)
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ Holds D I V (E_hd :: E_tl) (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) (E_hd :: E_tl) (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ Holds D I V (E_hd :: E_tl) (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) (E_hd :: E_tl) (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [sub]
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ Holds D I V (E_hd :: E_tl) (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) (E_hd :: E_tl) (def_ X xs)
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ Holds D I V (E_hd :: E_tl) (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) (E_hd :: E_tl) (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ Holds D I V (E_hd :: E_tl) (sub σ c (def_ X xs)) ↔ Holds D I (V ∘ σ) (E_hd :: E_tl) (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [Holds]
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ Holds D I V (E_hd :: E_tl) (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) (E_hd :: E_tl) (def_ X xs)
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ (if X = E_hd.name ∧ (List.map σ xs).length = E_hd.args.length then
Holds D I (Function.updateListITE V E_hd.args (List.map V (List.map σ xs))) E_tl E_hd.q
else Holds D I V E_tl (def_ X (List.map σ xs))) ↔
if X = E_hd.name ∧ xs.length = E_hd.args.length then
Holds D I (Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
else Holds D I (V ∘ σ) E_tl (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ Holds D I V (E_hd :: E_tl) (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) (E_hd :: E_tl) (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ (if X = E_hd.name ∧ (List.map σ xs).length = E_hd.args.length then
Holds D I (Function.updateListITE V E_hd.args (List.map V (List.map σ xs))) E_tl E_hd.q
else Holds D I V E_tl (def_ X (List.map σ xs))) ↔
if X = E_hd.name ∧ xs.length = E_hd.args.length then
Holds D I (Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
else Holds D I (V ∘ σ) E_tl (def_ X xs)
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ (if X = E_hd.name ∧ xs.length = E_hd.args.length then
Holds D I (Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
else Holds D I V E_tl (def_ X (List.map σ xs))) ↔
if X = E_hd.name ∧ xs.length = E_hd.args.length then
Holds D I (Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
else Holds D I (V ∘ σ) E_tl (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ (if X = E_hd.name ∧ (List.map σ xs).length = E_hd.args.length then
Holds D I (Function.updateListITE V E_hd.args (List.map V (List.map σ xs))) E_tl E_hd.q
else Holds D I V E_tl (def_ X (List.map σ xs))) ↔
if X = E_hd.name ∧ xs.length = E_hd.args.length then
Holds D I (Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
else Holds D I (V ∘ σ) E_tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
split_ifs
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ (if X = E_hd.name ∧ xs.length = E_hd.args.length then
Holds D I (Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
else Holds D I V E_tl (def_ X (List.map σ xs))) ↔
if X = E_hd.name ∧ xs.length = E_hd.args.length then
Holds D I (Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
else Holds D I (V ∘ σ) E_tl (def_ X xs)
|
case pos
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
h✝ : X = E_hd.name ∧ xs.length = E_hd.args.length
⊢ Holds D I (Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q ↔
Holds D I (Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
case neg
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
h✝ : ¬(X = E_hd.name ∧ xs.length = E_hd.args.length)
⊢ Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
⊢ (if X = E_hd.name ∧ xs.length = E_hd.args.length then
Holds D I (Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
else Holds D I V E_tl (def_ X (List.map σ xs))) ↔
if X = E_hd.name ∧ xs.length = E_hd.args.length then
Holds D I (Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
else Holds D I (V ∘ σ) E_tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
case neg c1 =>
exact E_ih
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : ¬(X = E_hd.name ∧ xs.length = E_hd.args.length)
⊢ Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : ¬(X = E_hd.name ∧ xs.length = E_hd.args.length)
⊢ Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
apply Holds_coincide_Var
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
⊢ Holds D I (Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q ↔
Holds D I (Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
|
case h1
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
⊢ ∀ (v : VarName),
isFreeIn v E_hd.q →
Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs) v =
Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
⊢ Holds D I (Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q ↔
Holds D I (Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs)) E_tl E_hd.q
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
intro v a1
|
case h1
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
⊢ ∀ (v : VarName),
isFreeIn v E_hd.q →
Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs) v =
Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs) v
|
case h1
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs) v =
Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
⊢ ∀ (v : VarName),
isFreeIn v E_hd.q →
Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs) v =
Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
apply Function.updateListITE_map_mem_ext
|
case h1
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs) v =
Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs) v
|
case h1.h1
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ ∀ y ∈ xs, (V ∘ σ) y = (V ∘ σ) y
case h1.h2
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ E_hd.args.length = xs.length
case h1.h3
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ v ∈ E_hd.args
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ Function.updateListITE V E_hd.args (List.map (V ∘ σ) xs) v =
Function.updateListITE (V ∘ σ) E_hd.args (List.map (V ∘ σ) xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp
|
case h1.h1
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ ∀ y ∈ xs, (V ∘ σ) y = (V ∘ σ) y
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h1
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ ∀ y ∈ xs, (V ∘ σ) y = (V ∘ σ) y
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
cases c1
|
case h1.h2
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ E_hd.args.length = xs.length
|
case h1.h2.intro
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
v : VarName
a1 : isFreeIn v E_hd.q
left✝ : X = E_hd.name
right✝ : xs.length = E_hd.args.length
⊢ E_hd.args.length = xs.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h2
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ E_hd.args.length = xs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
case _ c1_left c1_right =>
symm
exact c1_right
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
v : VarName
a1 : isFreeIn v E_hd.q
c1_left : X = E_hd.name
c1_right : xs.length = E_hd.args.length
⊢ E_hd.args.length = xs.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
v : VarName
a1 : isFreeIn v E_hd.q
c1_left : X = E_hd.name
c1_right : xs.length = E_hd.args.length
⊢ E_hd.args.length = xs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
symm
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
v : VarName
a1 : isFreeIn v E_hd.q
c1_left : X = E_hd.name
c1_right : xs.length = E_hd.args.length
⊢ E_hd.args.length = xs.length
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
v : VarName
a1 : isFreeIn v E_hd.q
c1_left : X = E_hd.name
c1_right : xs.length = E_hd.args.length
⊢ xs.length = E_hd.args.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
v : VarName
a1 : isFreeIn v E_hd.q
c1_left : X = E_hd.name
c1_right : xs.length = E_hd.args.length
⊢ E_hd.args.length = xs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
exact c1_right
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
v : VarName
a1 : isFreeIn v E_hd.q
c1_left : X = E_hd.name
c1_right : xs.length = E_hd.args.length
⊢ xs.length = E_hd.args.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
v : VarName
a1 : isFreeIn v E_hd.q
c1_left : X = E_hd.name
c1_right : xs.length = E_hd.args.length
⊢ xs.length = E_hd.args.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [isFreeIn_iff_mem_freeVarSet] at a1
|
case h1.h3
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ v ∈ E_hd.args
|
case h1.h3
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : v ∈ E_hd.q.freeVarSet
⊢ v ∈ E_hd.args
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h3
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : isFreeIn v E_hd.q
⊢ v ∈ E_hd.args
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
simp only [← List.mem_toFinset]
|
case h1.h3
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : v ∈ E_hd.q.freeVarSet
⊢ v ∈ E_hd.args
|
case h1.h3
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : v ∈ E_hd.q.freeVarSet
⊢ v ∈ E_hd.args.toFinset
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h3
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : v ∈ E_hd.q.freeVarSet
⊢ v ∈ E_hd.args
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
apply Finset.mem_of_subset E_hd.h1 a1
|
case h1.h3
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : v ∈ E_hd.q.freeVarSet
⊢ v ∈ E_hd.args.toFinset
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1.h3
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : X = E_hd.name ∧ xs.length = E_hd.args.length
v : VarName
a1 : v ∈ E_hd.q.freeVarSet
⊢ v ∈ E_hd.args.toFinset
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_theorem
|
[128, 1]
|
[245, 19]
|
exact E_ih
|
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : ¬(X = E_hd.name ∧ xs.length = E_hd.args.length)
⊢ Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
c : Char
X : DefName
xs : List VarName
V : VarAssignment D
σ : VarName → VarName
E_hd : Definition
E_tl : List Definition
E_ih : Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
c1 : ¬(X = E_hd.name ∧ xs.length = E_hd.args.length)
⊢ Holds D I V E_tl (def_ X (List.map σ xs)) ↔ Holds D I (V ∘ σ) E_tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_is_valid
|
[248, 1]
|
[260, 11]
|
simp only [IsValid] at h1
|
σ : VarName → VarName
c : Char
F : Formula
h1 : F.IsValid
⊢ (sub σ c F).IsValid
|
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ (sub σ c F).IsValid
|
Please generate a tactic in lean4 to solve the state.
STATE:
σ : VarName → VarName
c : Char
F : Formula
h1 : F.IsValid
⊢ (sub σ c F).IsValid
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_is_valid
|
[248, 1]
|
[260, 11]
|
simp only [IsValid]
|
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ (sub σ c F).IsValid
|
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (sub σ c F)
|
Please generate a tactic in lean4 to solve the state.
STATE:
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ (sub σ c F).IsValid
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_is_valid
|
[248, 1]
|
[260, 11]
|
intro D I V E
|
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (sub σ c F)
|
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I V E (sub σ c F)
|
Please generate a tactic in lean4 to solve the state.
STATE:
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
⊢ ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E (sub σ c F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_is_valid
|
[248, 1]
|
[260, 11]
|
simp only [substitution_theorem]
|
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I V E (sub σ c F)
|
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I (V ∘ σ) E F
|
Please generate a tactic in lean4 to solve the state.
STATE:
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I V E (sub σ c F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/All/Rec/Fresh/Sub.lean
|
FOL.NV.Sub.Var.All.Rec.Fresh.substitution_is_valid
|
[248, 1]
|
[260, 11]
|
apply h1
|
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I (V ∘ σ) E F
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
σ : VarName → VarName
c : Char
F : Formula
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D I (V ∘ σ) E F
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationEmpty
|
[208, 1]
|
[218, 7]
|
cases h1
|
V_N V_T : Type
R : V_N → PE V_N V_T
n : ℕ
xs : List V_T
o : Option (List V_T)
h1 : Interpretation V_N V_T R (empty, xs) (n, o)
⊢ n = 1 ∧ o = some []
|
case empty
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
⊢ 1 = 1 ∧ some [] = some []
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N → PE V_N V_T
n : ℕ
xs : List V_T
o : Option (List V_T)
h1 : Interpretation V_N V_T R (empty, xs) (n, o)
⊢ n = 1 ∧ o = some []
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationEmpty
|
[208, 1]
|
[218, 7]
|
simp
|
case empty
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
⊢ 1 = 1 ∧ some [] = some []
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case empty
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
⊢ 1 = 1 ∧ some [] = some []
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationSteps
|
[221, 1]
|
[233, 10]
|
cases h1
|
V_N V_T : Type
R : V_N → PE V_N V_T
e : PE V_N V_T
xs : List V_T
o : Option (List V_T)
n : ℕ
h1 : Interpretation V_N V_T R (e, xs) (n, o)
⊢ n > 0
|
case empty
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
⊢ 1 > 0
case terminal_success
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
⊢ 1 > 0
case terminal_failure_1
V_N V_T : Type
R : V_N → PE V_N V_T
a✝¹ b✝ : V_T
xs✝ : List V_T
a✝ : ¬a✝¹ = b✝
⊢ 1 > 0
case terminal_failure_2
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
⊢ 1 > 0
case nonTerminal
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
o : Option (List V_T)
A✝ : V_N
n✝ : ℕ
a✝ : Interpretation V_N V_T R (R A✝, xs) (n✝, o)
⊢ n✝ + 1 > 0
case seq_success
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e2✝, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
⊢ n1✝ + n2✝ + 1 > 0
case seq_failure_1
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e1✝ e2✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e1✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
case seq_failure_2
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs✝ ++ ys✝) (n1✝, some xs✝)
a✝ : Interpretation V_N V_T R (e2✝, ys✝) (n2✝, none)
⊢ n1✝ + n2✝ + 1 > 0
case choice_1
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs✝ ys✝ : List V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e1✝, xs✝ ++ ys✝) (n✝, some xs✝)
⊢ n✝ + 1 > 0
case choice_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
o : Option (List V_T)
e1✝ e2✝ : PE V_N V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs) (n1✝, none)
a✝ : Interpretation V_N V_T R (e2✝, xs) (n2✝, o)
⊢ n1✝ + n2✝ + 1 > 0
case star_repetition
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e✝.star, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
⊢ n1✝ + n2✝ + 1 > 0
case star_termination
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
case notP_1
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs✝ ys✝ : List V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs✝ ++ ys✝) (n✝, some xs✝)
⊢ n✝ + 1 > 0
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N → PE V_N V_T
e : PE V_N V_T
xs : List V_T
o : Option (List V_T)
n : ℕ
h1 : Interpretation V_N V_T R (e, xs) (n, o)
⊢ n > 0
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationSteps
|
[221, 1]
|
[233, 10]
|
all_goals
omega
|
case empty
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
⊢ 1 > 0
case terminal_success
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
⊢ 1 > 0
case terminal_failure_1
V_N V_T : Type
R : V_N → PE V_N V_T
a✝¹ b✝ : V_T
xs✝ : List V_T
a✝ : ¬a✝¹ = b✝
⊢ 1 > 0
case terminal_failure_2
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
⊢ 1 > 0
case nonTerminal
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
o : Option (List V_T)
A✝ : V_N
n✝ : ℕ
a✝ : Interpretation V_N V_T R (R A✝, xs) (n✝, o)
⊢ n✝ + 1 > 0
case seq_success
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e2✝, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
⊢ n1✝ + n2✝ + 1 > 0
case seq_failure_1
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e1✝ e2✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e1✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
case seq_failure_2
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs✝ ++ ys✝) (n1✝, some xs✝)
a✝ : Interpretation V_N V_T R (e2✝, ys✝) (n2✝, none)
⊢ n1✝ + n2✝ + 1 > 0
case choice_1
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs✝ ys✝ : List V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e1✝, xs✝ ++ ys✝) (n✝, some xs✝)
⊢ n✝ + 1 > 0
case choice_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
o : Option (List V_T)
e1✝ e2✝ : PE V_N V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs) (n1✝, none)
a✝ : Interpretation V_N V_T R (e2✝, xs) (n2✝, o)
⊢ n1✝ + n2✝ + 1 > 0
case star_repetition
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e✝.star, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
⊢ n1✝ + n2✝ + 1 > 0
case star_termination
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
case notP_1
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs✝ ys✝ : List V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs✝ ++ ys✝) (n✝, some xs✝)
⊢ n✝ + 1 > 0
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case empty
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
⊢ 1 > 0
case terminal_success
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
⊢ 1 > 0
case terminal_failure_1
V_N V_T : Type
R : V_N → PE V_N V_T
a✝¹ b✝ : V_T
xs✝ : List V_T
a✝ : ¬a✝¹ = b✝
⊢ 1 > 0
case terminal_failure_2
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
⊢ 1 > 0
case nonTerminal
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
o : Option (List V_T)
A✝ : V_N
n✝ : ℕ
a✝ : Interpretation V_N V_T R (R A✝, xs) (n✝, o)
⊢ n✝ + 1 > 0
case seq_success
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e2✝, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
⊢ n1✝ + n2✝ + 1 > 0
case seq_failure_1
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e1✝ e2✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e1✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
case seq_failure_2
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs✝ ++ ys✝) (n1✝, some xs✝)
a✝ : Interpretation V_N V_T R (e2✝, ys✝) (n2✝, none)
⊢ n1✝ + n2✝ + 1 > 0
case choice_1
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs✝ ys✝ : List V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e1✝, xs✝ ++ ys✝) (n✝, some xs✝)
⊢ n✝ + 1 > 0
case choice_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
o : Option (List V_T)
e1✝ e2✝ : PE V_N V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs) (n1✝, none)
a✝ : Interpretation V_N V_T R (e2✝, xs) (n2✝, o)
⊢ n1✝ + n2✝ + 1 > 0
case star_repetition
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e✝.star, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
⊢ n1✝ + n2✝ + 1 > 0
case star_termination
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
case notP_1
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs✝ ys✝ : List V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs✝ ++ ys✝) (n✝, some xs✝)
⊢ n✝ + 1 > 0
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationSteps
|
[221, 1]
|
[233, 10]
|
omega
|
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
⊢ n✝ + 1 > 0
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
EmptyStringPrefix
|
[236, 1]
|
[241, 27]
|
exact List.nil_prefix xs
|
α : Type
xs : List α
⊢ [].IsPrefix xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
xs : List α
⊢ [].IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
CharPrefix
|
[244, 1]
|
[250, 40]
|
exact List.prefix_iff_eq_take.mpr rfl
|
α : Type
x : α
xs : List α
⊢ [x].IsPrefix (x :: xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
x : α
xs : List α
⊢ [x].IsPrefix (x :: xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
PrefixAppend
|
[253, 1]
|
[258, 33]
|
exact List.prefix_append xs ys
|
α : Type
xs ys : List α
⊢ xs.IsPrefix (xs ++ ys)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
xs ys : List α
⊢ xs.IsPrefix (xs ++ ys)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
induction n using Nat.strongInductionOn generalizing e
|
V_N V_T : Type
R : V_N → PE V_N V_T
e : PE V_N V_T
xs ys : List V_T
n : ℕ
h1 : Interpretation V_N V_T R (e, xs) (n, some ys)
⊢ ys.IsPrefix xs
|
case ind
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
n✝ : ℕ
a✝ : ∀ m < n✝, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
e : PE V_N V_T
h1 : Interpretation V_N V_T R (e, xs) (n✝, some ys)
⊢ ys.IsPrefix xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N → PE V_N V_T
e : PE V_N V_T
xs ys : List V_T
n : ℕ
h1 : Interpretation V_N V_T R (e, xs) (n, some ys)
⊢ ys.IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
cases h1
|
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
n : ℕ
ih : ∀ m < n, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
e : PE V_N V_T
h1 : Interpretation V_N V_T R (e, xs) (n, some ys)
⊢ ys.IsPrefix xs
|
case empty
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
ih : ∀ m < 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
case terminal_success
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
ih : ∀ m < 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, a✝ :: xs✝) (m, some [a✝]) → [a✝].IsPrefix (a✝ :: xs✝)
⊢ [a✝].IsPrefix (a✝ :: xs✝)
case nonTerminal
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A✝ : V_N
n✝ : ℕ
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
a✝ : Interpretation V_N V_T R (R A✝, xs) (n✝, some ys)
⊢ ys.IsPrefix xs
case seq_success
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e2✝, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
ih :
∀ m < n1✝ + n2✝ + 1,
∀ (e : PE V_N V_T),
Interpretation V_N V_T R (e, xs_1✝ ++ xs_2✝ ++ ys✝) (m, some (xs_1✝ ++ xs_2✝)) →
(xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
⊢ (xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
case choice_1
V_N V_T : Type
R : V_N → PE V_N V_T
ys : List V_T
e1✝ e2✝ : PE V_N V_T
ys✝ : List V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e1✝, ys ++ ys✝) (n✝, some ys)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, ys ++ ys✝) (m, some ys) → ys.IsPrefix (ys ++ ys✝)
⊢ ys.IsPrefix (ys ++ ys✝)
case choice_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1✝ e2✝ : PE V_N V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs) (n1✝, none)
ih : ∀ m < n1✝ + n2✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
a✝ : Interpretation V_N V_T R (e2✝, xs) (n2✝, some ys)
⊢ ys.IsPrefix xs
case star_repetition
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e✝.star, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
ih :
∀ m < n1✝ + n2✝ + 1,
∀ (e : PE V_N V_T),
Interpretation V_N V_T R (e, xs_1✝ ++ xs_2✝ ++ ys✝) (m, some (xs_1✝ ++ xs_2✝)) →
(xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
⊢ (xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
case star_termination
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
n : ℕ
ih : ∀ m < n, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
e : PE V_N V_T
h1 : Interpretation V_N V_T R (e, xs) (n, some ys)
⊢ ys.IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
any_goals
first | apply EmptyStringPrefix | apply CharPrefix | apply PrefixAppend
|
case empty
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
ih : ∀ m < 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
case terminal_success
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
ih : ∀ m < 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, a✝ :: xs✝) (m, some [a✝]) → [a✝].IsPrefix (a✝ :: xs✝)
⊢ [a✝].IsPrefix (a✝ :: xs✝)
case nonTerminal
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A✝ : V_N
n✝ : ℕ
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
a✝ : Interpretation V_N V_T R (R A✝, xs) (n✝, some ys)
⊢ ys.IsPrefix xs
case seq_success
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e2✝, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
ih :
∀ m < n1✝ + n2✝ + 1,
∀ (e : PE V_N V_T),
Interpretation V_N V_T R (e, xs_1✝ ++ xs_2✝ ++ ys✝) (m, some (xs_1✝ ++ xs_2✝)) →
(xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
⊢ (xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
case choice_1
V_N V_T : Type
R : V_N → PE V_N V_T
ys : List V_T
e1✝ e2✝ : PE V_N V_T
ys✝ : List V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e1✝, ys ++ ys✝) (n✝, some ys)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, ys ++ ys✝) (m, some ys) → ys.IsPrefix (ys ++ ys✝)
⊢ ys.IsPrefix (ys ++ ys✝)
case choice_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1✝ e2✝ : PE V_N V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs) (n1✝, none)
ih : ∀ m < n1✝ + n2✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
a✝ : Interpretation V_N V_T R (e2✝, xs) (n2✝, some ys)
⊢ ys.IsPrefix xs
case star_repetition
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e✝.star, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
ih :
∀ m < n1✝ + n2✝ + 1,
∀ (e : PE V_N V_T),
Interpretation V_N V_T R (e, xs_1✝ ++ xs_2✝ ++ ys✝) (m, some (xs_1✝ ++ xs_2✝)) →
(xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
⊢ (xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
case star_termination
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
|
case nonTerminal
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A✝ : V_N
n✝ : ℕ
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
a✝ : Interpretation V_N V_T R (R A✝, xs) (n✝, some ys)
⊢ ys.IsPrefix xs
case choice_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1✝ e2✝ : PE V_N V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs) (n1✝, none)
ih : ∀ m < n1✝ + n2✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
a✝ : Interpretation V_N V_T R (e2✝, xs) (n2✝, some ys)
⊢ ys.IsPrefix xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case empty
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
ih : ∀ m < 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
case terminal_success
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
ih : ∀ m < 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, a✝ :: xs✝) (m, some [a✝]) → [a✝].IsPrefix (a✝ :: xs✝)
⊢ [a✝].IsPrefix (a✝ :: xs✝)
case nonTerminal
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A✝ : V_N
n✝ : ℕ
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
a✝ : Interpretation V_N V_T R (R A✝, xs) (n✝, some ys)
⊢ ys.IsPrefix xs
case seq_success
V_N V_T : Type
R : V_N → PE V_N V_T
e1✝ e2✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e2✝, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
ih :
∀ m < n1✝ + n2✝ + 1,
∀ (e : PE V_N V_T),
Interpretation V_N V_T R (e, xs_1✝ ++ xs_2✝ ++ ys✝) (m, some (xs_1✝ ++ xs_2✝)) →
(xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
⊢ (xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
case choice_1
V_N V_T : Type
R : V_N → PE V_N V_T
ys : List V_T
e1✝ e2✝ : PE V_N V_T
ys✝ : List V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e1✝, ys ++ ys✝) (n✝, some ys)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, ys ++ ys✝) (m, some ys) → ys.IsPrefix (ys ++ ys✝)
⊢ ys.IsPrefix (ys ++ ys✝)
case choice_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1✝ e2✝ : PE V_N V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e1✝, xs) (n1✝, none)
ih : ∀ m < n1✝ + n2✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
a✝ : Interpretation V_N V_T R (e2✝, xs) (n2✝, some ys)
⊢ ys.IsPrefix xs
case star_repetition
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e✝.star, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
ih :
∀ m < n1✝ + n2✝ + 1,
∀ (e : PE V_N V_T),
Interpretation V_N V_T R (e, xs_1✝ ++ xs_2✝ ++ ys✝) (m, some (xs_1✝ ++ xs_2✝)) →
(xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
⊢ (xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
case star_termination
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
first | apply EmptyStringPrefix | apply CharPrefix | apply PrefixAppend
|
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
apply EmptyStringPrefix
|
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case notP_2
V_N V_T : Type
R : V_N → PE V_N V_T
xs : List V_T
e✝ : PE V_N V_T
n✝ : ℕ
a✝ : Interpretation V_N V_T R (e✝, xs) (n✝, none)
ih : ∀ m < n✝ + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some []) → [].IsPrefix xs
⊢ [].IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
apply CharPrefix
|
case terminal_success
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
ih : ∀ m < 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, a✝ :: xs✝) (m, some [a✝]) → [a✝].IsPrefix (a✝ :: xs✝)
⊢ [a✝].IsPrefix (a✝ :: xs✝)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case terminal_success
V_N V_T : Type
R : V_N → PE V_N V_T
a✝ : V_T
xs✝ : List V_T
ih : ∀ m < 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, a✝ :: xs✝) (m, some [a✝]) → [a✝].IsPrefix (a✝ :: xs✝)
⊢ [a✝].IsPrefix (a✝ :: xs✝)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
apply PrefixAppend
|
case star_repetition
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e✝.star, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
ih :
∀ m < n1✝ + n2✝ + 1,
∀ (e : PE V_N V_T),
Interpretation V_N V_T R (e, xs_1✝ ++ xs_2✝ ++ ys✝) (m, some (xs_1✝ ++ xs_2✝)) →
(xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
⊢ (xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case star_repetition
V_N V_T : Type
R : V_N → PE V_N V_T
e✝ : PE V_N V_T
xs_1✝ xs_2✝ ys✝ : List V_T
n1✝ n2✝ : ℕ
a✝¹ : Interpretation V_N V_T R (e✝, xs_1✝ ++ xs_2✝ ++ ys✝) (n1✝, some xs_1✝)
a✝ : Interpretation V_N V_T R (e✝.star, xs_2✝ ++ ys✝) (n2✝, some xs_2✝)
ih :
∀ m < n1✝ + n2✝ + 1,
∀ (e : PE V_N V_T),
Interpretation V_N V_T R (e, xs_1✝ ++ xs_2✝ ++ ys✝) (m, some (xs_1✝ ++ xs_2✝)) →
(xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
⊢ (xs_1✝ ++ xs_2✝).IsPrefix (xs_1✝ ++ xs_2✝ ++ ys✝)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
specialize ih n _ (R A)
|
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A : V_N
n : ℕ
ih : ∀ m < n + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
⊢ ys.IsPrefix xs
|
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A : V_N
n : ℕ
ih : ∀ m < n + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
⊢ n < n + 1
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A : V_N
n : ℕ
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
ih : Interpretation V_N V_T R (R A, xs) (n, some ys) → ys.IsPrefix xs
⊢ ys.IsPrefix xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A : V_N
n : ℕ
ih : ∀ m < n + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
⊢ ys.IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
omega
|
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A : V_N
n : ℕ
ih : ∀ m < n + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
⊢ n < n + 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A : V_N
n : ℕ
ih : ∀ m < n + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
⊢ n < n + 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
exact ih ih_1
|
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A : V_N
n : ℕ
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
ih : Interpretation V_N V_T R (R A, xs) (n, some ys) → ys.IsPrefix xs
⊢ ys.IsPrefix xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
A : V_N
n : ℕ
ih_1 : Interpretation V_N V_T R (R A, xs) (n, some ys)
ih : Interpretation V_N V_T R (R A, xs) (n, some ys) → ys.IsPrefix xs
⊢ ys.IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
specialize ih n2 _ e2
|
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : ℕ
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih : ∀ m < n1 + n2 + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
⊢ ys.IsPrefix xs
|
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : ℕ
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih : ∀ m < n1 + n2 + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
⊢ n2 < n1 + n2 + 1
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : ℕ
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
ih : Interpretation V_N V_T R (e2, xs) (n2, some ys) → ys.IsPrefix xs
⊢ ys.IsPrefix xs
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : ℕ
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih : ∀ m < n1 + n2 + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
⊢ ys.IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
omega
|
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : ℕ
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih : ∀ m < n1 + n2 + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
⊢ n2 < n1 + n2 + 1
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : ℕ
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih : ∀ m < n1 + n2 + 1, ∀ (e : PE V_N V_T), Interpretation V_N V_T R (e, xs) (m, some ys) → ys.IsPrefix xs
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
⊢ n2 < n1 + n2 + 1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Program/PEG.lean
|
InterpretationPrefix
|
[264, 1]
|
[285, 20]
|
exact ih ih_2
|
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : ℕ
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
ih : Interpretation V_N V_T R (e2, xs) (n2, some ys) → ys.IsPrefix xs
⊢ ys.IsPrefix xs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
V_N V_T : Type
R : V_N → PE V_N V_T
xs ys : List V_T
e1 e2 : PE V_N V_T
n1 n2 : ℕ
ih_1 : Interpretation V_N V_T R (e1, xs) (n1, none)
ih_2 : Interpretation V_N V_T R (e2, xs) (n2, some ys)
ih : Interpretation V_N V_T R (e2, xs) (n2, some ys) → ys.IsPrefix xs
⊢ ys.IsPrefix xs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Ind/Sub.lean
|
FOL.NV.Sub.Var.One.Ind.fastAdmitsAux_and_fastReplaceFree_imp_isFreeSub
|
[125, 1]
|
[194, 21]
|
subst h2
|
F F' : Formula
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders F
h2 : Rec.fastReplaceFree v u F = F'
⊢ IsSub F v u F'
|
F : Formula
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders F
⊢ IsSub F v u (Rec.fastReplaceFree v u F)
|
Please generate a tactic in lean4 to solve the state.
STATE:
F F' : Formula
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders F
h2 : Rec.fastReplaceFree v u F = F'
⊢ IsSub F v u F'
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Ind/Sub.lean
|
FOL.NV.Sub.Var.One.Ind.fastAdmitsAux_and_fastReplaceFree_imp_isFreeSub
|
[125, 1]
|
[194, 21]
|
induction F generalizing binders
|
F : Formula
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders F
⊢ IsSub F v u (Rec.fastReplaceFree v u F)
|
case pred_const_
v u : VarName
a✝¹ : PredName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (pred_const_ a✝¹ a✝)
⊢ IsSub (pred_const_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (pred_const_ a✝¹ a✝))
case pred_var_
v u : VarName
a✝¹ : PredName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (pred_var_ a✝¹ a✝)
⊢ IsSub (pred_var_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (pred_var_ a✝¹ a✝))
case eq_
v u a✝¹ a✝ : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (eq_ a✝¹ a✝)
⊢ IsSub (eq_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (eq_ a✝¹ a✝))
case true_
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders true_
⊢ IsSub true_ v u (Rec.fastReplaceFree v u true_)
case false_
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders false_
⊢ IsSub false_ v u (Rec.fastReplaceFree v u false_)
case not_
v u : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders a✝.not_
⊢ IsSub a✝.not_ v u (Rec.fastReplaceFree v u a✝.not_)
case imp_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.imp_ a✝)
⊢ IsSub (a✝¹.imp_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.imp_ a✝))
case and_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.and_ a✝)
⊢ IsSub (a✝¹.and_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.and_ a✝))
case or_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.or_ a✝)
⊢ IsSub (a✝¹.or_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.or_ a✝))
case iff_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.iff_ a✝)
⊢ IsSub (a✝¹.iff_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.iff_ a✝))
case forall_
v u a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (forall_ a✝¹ a✝)
⊢ IsSub (forall_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (forall_ a✝¹ a✝))
case exists_
v u a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (exists_ a✝¹ a✝)
⊢ IsSub (exists_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (exists_ a✝¹ a✝))
case def_
v u : VarName
a✝¹ : DefName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (def_ a✝¹ a✝)
⊢ IsSub (def_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (def_ a✝¹ a✝))
|
Please generate a tactic in lean4 to solve the state.
STATE:
F : Formula
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders F
⊢ IsSub F v u (Rec.fastReplaceFree v u F)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Ind/Sub.lean
|
FOL.NV.Sub.Var.One.Ind.fastAdmitsAux_and_fastReplaceFree_imp_isFreeSub
|
[125, 1]
|
[194, 21]
|
all_goals
simp only [Rec.fastAdmitsAux] at h1
simp only [Rec.fastReplaceFree]
|
case pred_const_
v u : VarName
a✝¹ : PredName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (pred_const_ a✝¹ a✝)
⊢ IsSub (pred_const_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (pred_const_ a✝¹ a✝))
case pred_var_
v u : VarName
a✝¹ : PredName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (pred_var_ a✝¹ a✝)
⊢ IsSub (pred_var_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (pred_var_ a✝¹ a✝))
case eq_
v u a✝¹ a✝ : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (eq_ a✝¹ a✝)
⊢ IsSub (eq_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (eq_ a✝¹ a✝))
case true_
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders true_
⊢ IsSub true_ v u (Rec.fastReplaceFree v u true_)
case false_
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders false_
⊢ IsSub false_ v u (Rec.fastReplaceFree v u false_)
case not_
v u : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders a✝.not_
⊢ IsSub a✝.not_ v u (Rec.fastReplaceFree v u a✝.not_)
case imp_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.imp_ a✝)
⊢ IsSub (a✝¹.imp_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.imp_ a✝))
case and_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.and_ a✝)
⊢ IsSub (a✝¹.and_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.and_ a✝))
case or_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.or_ a✝)
⊢ IsSub (a✝¹.or_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.or_ a✝))
case iff_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.iff_ a✝)
⊢ IsSub (a✝¹.iff_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.iff_ a✝))
case forall_
v u a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (forall_ a✝¹ a✝)
⊢ IsSub (forall_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (forall_ a✝¹ a✝))
case exists_
v u a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (exists_ a✝¹ a✝)
⊢ IsSub (exists_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (exists_ a✝¹ a✝))
case def_
v u : VarName
a✝¹ : DefName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (def_ a✝¹ a✝)
⊢ IsSub (def_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (def_ a✝¹ a✝))
|
case pred_const_
v u : VarName
a✝¹ : PredName
a✝ : List VarName
binders : Finset VarName
h1 : v ∈ a✝ → u ∉ binders
⊢ IsSub (pred_const_ a✝¹ a✝) v u (pred_const_ a✝¹ (List.map (fun x => if v = x then u else x) a✝))
case pred_var_
v u : VarName
a✝¹ : PredName
a✝ : List VarName
binders : Finset VarName
h1 : v ∈ a✝ → u ∉ binders
⊢ IsSub (pred_var_ a✝¹ a✝) v u (pred_var_ a✝¹ (List.map (fun x => if v = x then u else x) a✝))
case eq_
v u a✝¹ a✝ : VarName
binders : Finset VarName
h1 : v = a✝¹ ∨ v = a✝ → u ∉ binders
⊢ IsSub (eq_ a✝¹ a✝) v u (eq_ (if v = a✝¹ then u else a✝¹) (if v = a✝ then u else a✝))
case true_
v u : VarName
binders : Finset VarName
h1 : True
⊢ IsSub true_ v u true_
case false_
v u : VarName
binders : Finset VarName
h1 : True
⊢ IsSub false_ v u false_
case not_
v u : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders a✝
⊢ IsSub a✝.not_ v u (Rec.fastReplaceFree v u a✝).not_
case imp_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders a✝¹ ∧ Rec.fastAdmitsAux v u binders a✝
⊢ IsSub (a✝¹.imp_ a✝) v u ((Rec.fastReplaceFree v u a✝¹).imp_ (Rec.fastReplaceFree v u a✝))
case and_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders a✝¹ ∧ Rec.fastAdmitsAux v u binders a✝
⊢ IsSub (a✝¹.and_ a✝) v u ((Rec.fastReplaceFree v u a✝¹).and_ (Rec.fastReplaceFree v u a✝))
case or_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders a✝¹ ∧ Rec.fastAdmitsAux v u binders a✝
⊢ IsSub (a✝¹.or_ a✝) v u ((Rec.fastReplaceFree v u a✝¹).or_ (Rec.fastReplaceFree v u a✝))
case iff_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders a✝¹ ∧ Rec.fastAdmitsAux v u binders a✝
⊢ IsSub (a✝¹.iff_ a✝) v u ((Rec.fastReplaceFree v u a✝¹).iff_ (Rec.fastReplaceFree v u a✝))
case forall_
v u a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : v = a✝¹ ∨ Rec.fastAdmitsAux v u (binders ∪ {a✝¹}) a✝
⊢ IsSub (forall_ a✝¹ a✝) v u (if v = a✝¹ then forall_ a✝¹ a✝ else forall_ a✝¹ (Rec.fastReplaceFree v u a✝))
case exists_
v u a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : v = a✝¹ ∨ Rec.fastAdmitsAux v u (binders ∪ {a✝¹}) a✝
⊢ IsSub (exists_ a✝¹ a✝) v u (if v = a✝¹ then exists_ a✝¹ a✝ else exists_ a✝¹ (Rec.fastReplaceFree v u a✝))
case def_
v u : VarName
a✝¹ : DefName
a✝ : List VarName
binders : Finset VarName
h1 : v ∈ a✝ → u ∉ binders
⊢ IsSub (def_ a✝¹ a✝) v u (def_ a✝¹ (List.map (fun x => if v = x then u else x) a✝))
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pred_const_
v u : VarName
a✝¹ : PredName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (pred_const_ a✝¹ a✝)
⊢ IsSub (pred_const_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (pred_const_ a✝¹ a✝))
case pred_var_
v u : VarName
a✝¹ : PredName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (pred_var_ a✝¹ a✝)
⊢ IsSub (pred_var_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (pred_var_ a✝¹ a✝))
case eq_
v u a✝¹ a✝ : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (eq_ a✝¹ a✝)
⊢ IsSub (eq_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (eq_ a✝¹ a✝))
case true_
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders true_
⊢ IsSub true_ v u (Rec.fastReplaceFree v u true_)
case false_
v u : VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders false_
⊢ IsSub false_ v u (Rec.fastReplaceFree v u false_)
case not_
v u : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders a✝.not_
⊢ IsSub a✝.not_ v u (Rec.fastReplaceFree v u a✝.not_)
case imp_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.imp_ a✝)
⊢ IsSub (a✝¹.imp_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.imp_ a✝))
case and_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.and_ a✝)
⊢ IsSub (a✝¹.and_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.and_ a✝))
case or_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.or_ a✝)
⊢ IsSub (a✝¹.or_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.or_ a✝))
case iff_
v u : VarName
a✝¹ a✝ : Formula
a_ih✝¹ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝¹ → IsSub a✝¹ v u (Rec.fastReplaceFree v u a✝¹)
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (a✝¹.iff_ a✝)
⊢ IsSub (a✝¹.iff_ a✝) v u (Rec.fastReplaceFree v u (a✝¹.iff_ a✝))
case forall_
v u a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (forall_ a✝¹ a✝)
⊢ IsSub (forall_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (forall_ a✝¹ a✝))
case exists_
v u a✝¹ : VarName
a✝ : Formula
a_ih✝ : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders a✝ → IsSub a✝ v u (Rec.fastReplaceFree v u a✝)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (exists_ a✝¹ a✝)
⊢ IsSub (exists_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (exists_ a✝¹ a✝))
case def_
v u : VarName
a✝¹ : DefName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (def_ a✝¹ a✝)
⊢ IsSub (def_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (def_ a✝¹ a✝))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Ind/Sub.lean
|
FOL.NV.Sub.Var.One.Ind.fastAdmitsAux_and_fastReplaceFree_imp_isFreeSub
|
[125, 1]
|
[194, 21]
|
case pred_const_ X xs | pred_var_ X xs =>
first | apply IsSub.pred_const_ | apply IsSub.pred_var_
|
v u : VarName
X : PredName
xs : List VarName
binders : Finset VarName
h1 : v ∈ xs → u ∉ binders
⊢ IsSub (pred_var_ X xs) v u (pred_var_ X (List.map (fun x => if v = x then u else x) xs))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
v u : VarName
X : PredName
xs : List VarName
binders : Finset VarName
h1 : v ∈ xs → u ∉ binders
⊢ IsSub (pred_var_ X xs) v u (pred_var_ X (List.map (fun x => if v = x then u else x) xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Ind/Sub.lean
|
FOL.NV.Sub.Var.One.Ind.fastAdmitsAux_and_fastReplaceFree_imp_isFreeSub
|
[125, 1]
|
[194, 21]
|
case eq_ x y =>
apply IsSub.eq_
|
v u x y : VarName
binders : Finset VarName
h1 : v = x ∨ v = y → u ∉ binders
⊢ IsSub (eq_ x y) v u (eq_ (if v = x then u else x) (if v = y then u else y))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
v u x y : VarName
binders : Finset VarName
h1 : v = x ∨ v = y → u ∉ binders
⊢ IsSub (eq_ x y) v u (eq_ (if v = x then u else x) (if v = y then u else y))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Ind/Sub.lean
|
FOL.NV.Sub.Var.One.Ind.fastAdmitsAux_and_fastReplaceFree_imp_isFreeSub
|
[125, 1]
|
[194, 21]
|
case true_ | false_ =>
first | apply IsSub.true_ | apply IsSub.false_
|
v u : VarName
binders : Finset VarName
h1 : True
⊢ IsSub false_ v u false_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
v u : VarName
binders : Finset VarName
h1 : True
⊢ IsSub false_ v u false_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Ind/Sub.lean
|
FOL.NV.Sub.Var.One.Ind.fastAdmitsAux_and_fastReplaceFree_imp_isFreeSub
|
[125, 1]
|
[194, 21]
|
case not_ phi phi_ih =>
apply IsSub.not_
exact phi_ih binders h1
|
v u : VarName
phi : Formula
phi_ih : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders phi → IsSub phi v u (Rec.fastReplaceFree v u phi)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders phi
⊢ IsSub phi.not_ v u (Rec.fastReplaceFree v u phi).not_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
v u : VarName
phi : Formula
phi_ih : ∀ (binders : Finset VarName), Rec.fastAdmitsAux v u binders phi → IsSub phi v u (Rec.fastReplaceFree v u phi)
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders phi
⊢ IsSub phi.not_ v u (Rec.fastReplaceFree v u phi).not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Ind/Sub.lean
|
FOL.NV.Sub.Var.One.Ind.fastAdmitsAux_and_fastReplaceFree_imp_isFreeSub
|
[125, 1]
|
[194, 21]
|
case def_ X xs =>
apply IsSub.def_
|
v u : VarName
X : DefName
xs : List VarName
binders : Finset VarName
h1 : v ∈ xs → u ∉ binders
⊢ IsSub (def_ X xs) v u (def_ X (List.map (fun x => if v = x then u else x) xs))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
v u : VarName
X : DefName
xs : List VarName
binders : Finset VarName
h1 : v ∈ xs → u ∉ binders
⊢ IsSub (def_ X xs) v u (def_ X (List.map (fun x => if v = x then u else x) xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Var/One/Ind/Sub.lean
|
FOL.NV.Sub.Var.One.Ind.fastAdmitsAux_and_fastReplaceFree_imp_isFreeSub
|
[125, 1]
|
[194, 21]
|
simp only [Rec.fastAdmitsAux] at h1
|
case def_
v u : VarName
a✝¹ : DefName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (def_ a✝¹ a✝)
⊢ IsSub (def_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (def_ a✝¹ a✝))
|
case def_
v u : VarName
a✝¹ : DefName
a✝ : List VarName
binders : Finset VarName
h1 : v ∈ a✝ → u ∉ binders
⊢ IsSub (def_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (def_ a✝¹ a✝))
|
Please generate a tactic in lean4 to solve the state.
STATE:
case def_
v u : VarName
a✝¹ : DefName
a✝ : List VarName
binders : Finset VarName
h1 : Rec.fastAdmitsAux v u binders (def_ a✝¹ a✝)
⊢ IsSub (def_ a✝¹ a✝) v u (Rec.fastReplaceFree v u (def_ a✝¹ a✝))
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.