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/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
obtain s1 := Sub.Var.All.Rec.Fresh.substitution_theorem D I V E (Function.updateListITE id zs xs) c H
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (V β Function.updateListITE id zs xs) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Function.updateListITE_comp] at s1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (V β Function.updateListITE id zs xs) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE (V β id) zs (List.map V xs)) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (V β Function.updateListITE id zs xs) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp at s1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE (V β id) zs (List.map V xs)) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE (V β id) zs (List.map V xs)) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [s1]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I V E
(Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
apply Holds_coincide_Var
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
β’ β (v : VarName),
isFreeIn v ((Ο X xs.length).get β―).2 β
Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v =
Function.updateListITE V zs (List.map V xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
β’ Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2 β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
intro v a1
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
β’ β (v : VarName),
isFreeIn v ((Ο X xs.length).get β―).2 β
Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v =
Function.updateListITE V zs (List.map V xs) v
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
β’ β (v : VarName),
isFreeIn v ((Ο X xs.length).get β―).2 β
Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v =
Function.updateListITE V zs (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
by_cases c3 : v β zs
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
apply Function.updateListITE_mem_eq_len V' V v zs (List.map V xs) c3
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ zs.length = (List.map V xs).length
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ zs.length = (List.map V xs).length
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ zs.length = xs.length
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ zs.length = (List.map V xs).length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [β c2]
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ zs.length = xs.length
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ zs.length = xs.length
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Function.updateListITE_not_mem V v zs (List.map V xs) c3]
|
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
|
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = Function.updateListITE V zs (List.map V xs) v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Function.updateListITE_not_mem V' v zs (List.map V xs) c3]
|
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = V v
|
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ V' v = V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs) v = V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
apply h2
|
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ V' v = V v
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ v β binders
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ V' v = V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
intro contra
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ v β binders
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
contra : v β binders
β’ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
β’ v β binders
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [isFreeIn_iff_mem_freeVarSet] at a1
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
contra : v β binders
β’ False
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
β’ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
a1 : isFreeIn v ((Ο X xs.length).get β―).2
c3 : v β zs
contra : v β binders
β’ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Finset.eq_empty_iff_forall_not_mem] at h1
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
β’ False
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
β (x : VarName), x β binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset)
else True
β’ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
β’ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [c1] at h1
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
β (x : VarName), x β binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset)
else True
β’ False
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 :
if h : True then
xs.length = ((Ο X xs.length).get β―).1.length β
β (x : VarName), x β binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset)
else True
β’ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
β (x : VarName), x β binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset)
else True
β’ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [β c2] at h1
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 :
if h : True then
xs.length = ((Ο X xs.length).get β―).1.length β
β (x : VarName), x β binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset)
else True
β’ False
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 :
if h : True then
True β β (x : VarName), x β binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset)
else True
β’ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 :
if h : True then
xs.length = ((Ο X xs.length).get β―).1.length β
β (x : VarName), x β binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset)
else True
β’ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp at h1
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 :
if h : True then
True β β (x : VarName), x β binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset)
else True
β’ False
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 : β x β binders, x β ((Ο X xs.length).get β―).2.freeVarSet β x β ((Ο X xs.length).get β―).1
β’ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 :
if h : True then
True β β (x : VarName), x β binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset)
else True
β’ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
specialize h1 v contra a1
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 : β x β binders, x β ((Ο X xs.length).get β―).2.freeVarSet β x β ((Ο X xs.length).get β―).1
β’ False
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 : v β ((Ο X xs.length).get β―).1
β’ False
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 : β x β binders, x β ((Ο X xs.length).get β―).2.freeVarSet β x β ((Ο X xs.length).get β―).1
β’ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
contradiction
|
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 : v β ((Ο X xs.length).get β―).1
β’ False
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case neg.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
c1 : (Ο X xs.length).isSome = true
c2 : xs.length = ((Ο X xs.length).get β―).1.length
opt : Option (List VarName Γ Formula) := Ο X xs.length
val : List VarName Γ Formula := opt.get c1
zs : List VarName := val.1
H : Formula := val.2
s1 :
Holds D I V E (Var.All.Rec.Fresh.sub (Function.updateListITE id zs xs) c H) β
Holds D I (Function.updateListITE V zs (List.map V xs)) E H
v : VarName
c3 : v β zs
contra : v β binders
a1 : v β ((Ο X xs.length).get β―).2.freeVarSet
h1 : v β ((Ο X xs.length).get β―).1
β’ False
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : Β¬xs.length = ((Ο X xs.length).get β―).1.length
β’ I.pred_var_ X (List.map V xs) β Holds D I V E (pred_var_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : (Ο X xs.length).isSome = true
c2 : Β¬xs.length = ((Ο X xs.length).get β―).1.length
β’ I.pred_var_ X (List.map V xs) β Holds D I V E (pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : Β¬(Ο X xs.length).isSome = true
β’ I.pred_var_ X (List.map V xs) β Holds D I V E (pred_var_ X xs)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1 :
if h : (Ο X xs.length).isSome = true then
xs.length = ((Ο X xs.length).get β―).1.length β
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
c1 : Β¬(Ο X xs.length).isSome = true
β’ I.pred_var_ X (List.map V xs) β Holds D I V E (pred_var_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (replace c Ο (eq_ x y))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (eq_ x y)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (replace c Ο (eq_ x y))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (eq_ x y)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x y : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ x y)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (eq_ x y) β
Holds D I V E (eq_ x y)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E false_ β
Holds D I V E (replace c Ο false_)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E false_ β
Holds D I V E false_
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E false_ β
Holds D I V E (replace c Ο false_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E false_ β
Holds D I V E false_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders false_
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E false_ β
Holds D I V E false_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [admitsAux] at h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi.not_
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace c Ο phi.not_)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace c Ο phi.not_)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi.not_
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace c Ο phi.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace c Ο phi.not_)
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace c Ο phi).not_
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace c Ο phi.not_)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace c Ο phi).not_
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Β¬Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Β¬Holds D I V E (replace c Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi.not_ β
Holds D I V E (replace c Ο phi).not_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
congr! 1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Β¬Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Β¬Holds D I V E (replace c Ο phi)
|
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Β¬Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Β¬Holds D I V E (replace c Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
exact phi_ih V binders h1 h2
|
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [admitsAux] at h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (phi.iff_ psi)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E (replace c Ο (phi.iff_ psi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E (replace c Ο (phi.iff_ psi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (phi.iff_ psi)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E (replace c Ο (phi.iff_ psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E (replace c Ο (phi.iff_ psi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E ((replace c Ο phi).iff_ (replace c Ο psi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E (replace c Ο (phi.iff_ psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E ((replace c Ο phi).iff_ (replace c Ο psi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V' x = V x
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace c Ο phi) β Holds D I V E (replace c Ο psi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (phi.iff_ psi) β
Holds D I V E ((replace c Ο phi).iff_ (replace c Ο psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
cases h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V' x = V x
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace c Ο phi) β Holds D I V E (replace c Ο psi))
|
case intro
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
leftβ : admitsAux Ο binders phi
rightβ : admitsAux Ο binders psi
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace c Ο phi) β Holds D I V E (replace c Ο psi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders phi β§ admitsAux Ο binders psi
h2 : β x β binders, V' x = V x
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace c Ο phi) β Holds D I V E (replace c Ο psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
congr! 1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace c Ο phi) β Holds D I V E (replace c Ο psi))
|
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi)
case a.h.e'_2.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ (Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi) β
(Holds D I V E (replace c Ο phi) β Holds D I V E (replace c Ο psi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
exact phi_ih V binders h1_left h2
|
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_1.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
exact psi_ih V binders h1_right h2
|
case a.h.e'_2.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case a.h.e'_2.a
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
phi psi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
psi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders psi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi))
V : VarAssignment D
binders : Finset VarName
h2 : β x β binders, V' x = V x
h1_left : admitsAux Ο binders phi
h1_right : admitsAux Ο binders psi
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E psi β
Holds D I V E (replace c Ο psi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [admitsAux] at h1
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (exists_ x phi)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace c Ο (exists_ x phi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace c Ο (exists_ x phi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (exists_ x phi)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace c Ο (exists_ x phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace c Ο (exists_ x phi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (exists_ x (replace c Ο phi))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (replace c Ο (exists_ x phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (exists_ x (replace c Ο phi))
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ (β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β d, Holds D I (Function.updateITE V x d) E (replace c Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (exists_ x phi) β
Holds D I V E (exists_ x (replace c Ο phi))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
first | apply forall_congr' | apply exists_congr
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ (β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β d, Holds D I (Function.updateITE V x d) E (replace c Ο phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ β (a : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x a) E phi β
Holds D I (Function.updateITE V x a) E (replace c Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ (β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β d, Holds D I (Function.updateITE V x d) E (replace c Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
intro d
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ β (a : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x a) E phi β
Holds D I (Function.updateITE V x a) E (replace c Ο phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi β
Holds D I (Function.updateITE V x d) E (replace c Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ β (a : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x a) E phi β
Holds D I (Function.updateITE V x a) E (replace c Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
apply phi_ih (Function.updateITE V x d) (binders βͺ {x}) h1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi β
Holds D I (Function.updateITE V x d) E (replace c Ο phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
β’ β x_1 β binders βͺ {x}, V' x_1 = Function.updateITE V x d x_1
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi β
Holds D I (Function.updateITE V x d) E (replace c Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
intro v a1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
β’ β x_1 β binders βͺ {x}, V' x_1 = Function.updateITE V x d x_1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ V' 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
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
β’ β x_1 β binders βͺ {x}, V' x_1 = Function.updateITE V x d x_1
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Function.updateITE]
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ V' v = Function.updateITE V x d v
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ V' v = if v = x then d else V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ V' v = Function.updateITE V x d v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp at a1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ V' v = if v = x then d else V v
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders β§ Β¬v = x
β’ V' v = if v = x then d else V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders βͺ {x}
β’ V' v = if v = x then d else V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
push_neg at a1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders β§ Β¬v = x
β’ V' v = if v = x then d else V v
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders β§ v β x
β’ V' v = if v = x then d else V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders β§ Β¬v = x
β’ V' v = if v = x then d else V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
cases a1
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders β§ v β x
β’ V' v = if v = x then d else V v
|
case h.intro
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
leftβ : v β binders
rightβ : v β x
β’ V' v = if v = x then d else V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1 : v β binders β§ v β x
β’ V' v = if v = x then d else V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
case h.intro a1_left a1_right =>
simp only [if_neg a1_right]
exact h2 v a1_left
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ V' v = if v = x then d else V v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ V' v = if v = x then d else V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
apply forall_congr'
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ (β (d : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β (d : D), Holds D I (Function.updateITE V x d) E (replace c Ο phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ β (a : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x a) E phi β
Holds D I (Function.updateITE V x a) E (replace c Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ (β (d : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β (d : D), Holds D I (Function.updateITE V x d) E (replace c Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
apply exists_congr
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ (β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β d, Holds D I (Function.updateITE V x d) E (replace c Ο phi)
|
case h
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ β (a : D),
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x a) E phi β
Holds D I (Function.updateITE V x a) E (replace c Ο phi)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
β’ (β d,
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateITE V x d) E phi) β
β d, Holds D I (Function.updateITE V x d) E (replace c Ο phi)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [if_neg a1_right]
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ V' v = if v = x then d else V v
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ V' v = V v
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ V' v = if v = x then d else V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
exact h2 v a1_left
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ V' v = V v
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
x : VarName
phi : Formula
phi_ih :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders phi β
(β x β binders, V' x = V x) β
(Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E phi β
Holds D I V E (replace c Ο phi))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο (binders βͺ {x}) phi
h2 : β x β binders, V' x = V x
d : D
v : VarName
a1_left : v β binders
a1_right : v β x
β’ V' v = V v
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
cases E
|
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (def_ X xs) β
Holds D I V E (replace c Ο (def_ X xs))
|
case nil
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (replace c Ο (def_ X xs))
case cons
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
headβ : Definition
tailβ : List Definition
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) (headβ :: tailβ) H
else I.pred_var_ X ds
else I.pred_var_ X ds }
V (headβ :: tailβ) (def_ X xs) β
Holds D I V (headβ :: tailβ) (replace c Ο (def_ X xs))
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) E H else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (def_ X xs) β
Holds D I V E (replace c Ο (def_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
case nil =>
simp only [replace]
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (replace c Ο (def_ X xs))
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (replace c Ο (def_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (replace c Ο (def_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) [] ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) [] H else I.pred_var_ X ds
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (replace c Ο (def_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) [] ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V [] (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
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) [] ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V [] (def_ X xs) β
Holds D I V [] (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [replace]
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) (hd :: tl) H else I.pred_var_ X ds
else I.pred_var_ X ds }
V (hd :: tl) (def_ X xs) β
Holds D I V (hd :: tl) (replace c Ο (def_ X xs))
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V (hd :: tl) (def_ X xs) β
Holds D I V (hd :: tl) (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
let opt := Ο X ds.length;
if h : opt.isSome = true then
let val := opt.get h;
let zs := val.1;
let H := val.2;
if ds.length = zs.length then Holds D I (Function.updateListITE V' zs ds) (hd :: tl) H else I.pred_var_ X ds
else I.pred_var_ X ds }
V (hd :: tl) (def_ X xs) β
Holds D I V (hd :: tl) (replace c Ο (def_ X xs))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [Holds]
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V (hd :: tl) (def_ X xs) β
Holds D I V (hd :: tl) (def_ X xs)
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
β’ (if X = hd.name β§ xs.length = hd.args.length then
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V tl (def_ X xs)) β
if X = hd.name β§ xs.length = hd.args.length then
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else Holds D I V tl (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V (hd :: tl) (def_ X xs) β
Holds D I V (hd :: tl) (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
split_ifs
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
β’ (if X = hd.name β§ xs.length = hd.args.length then
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V tl (def_ X xs)) β
if X = hd.name β§ xs.length = hd.args.length then
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else Holds D I V tl (def_ X xs)
|
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
hβ : X = hd.name β§ xs.length = hd.args.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
case neg
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
hβ : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V tl (def_ X xs) β
Holds D I V tl (def_ X xs)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
β’ (if X = hd.name β§ xs.length = hd.args.length then
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else
Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V tl (def_ X xs)) β
if X = hd.name β§ xs.length = hd.args.length then
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
else Holds D I V tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
apply Holds_coincide_PredVar
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ { nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_const_ =
I.pred_const_
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ β (P : PredName) (ds : List D),
predVarOccursIn P ds.length hd.q β
({ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl)
((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_var_
P ds β
I.pred_var_ P ds)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
(Function.updateListITE V hd.args (List.map V xs)) tl hd.q β
Holds D I (Function.updateListITE V hd.args (List.map V xs)) tl hd.q
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ { nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_const_ =
I.pred_const_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ { nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_const_ =
I.pred_const_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [predVarOccursIn_iff_mem_predVarSet]
|
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ β (P : PredName) (ds : List D),
predVarOccursIn P ds.length hd.q β
({ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl)
((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_var_
P ds β
I.pred_var_ P ds)
|
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ β (P : PredName) (ds : List D),
(P, ds.length) β hd.q.predVarSet β
((if h : (Ο P ds.length).isSome = true then
if ds.length = ((Ο P ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο P ds.length).get β―).1 ds) (hd :: tl) ((Ο P ds.length).get β―).2
else I.pred_var_ P ds
else I.pred_var_ P ds) β
I.pred_var_ P ds)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ β (P : PredName) (ds : List D),
predVarOccursIn P ds.length hd.q β
({ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl)
((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_var_
P ds β
I.pred_var_ P ds)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [hd.h2]
|
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ β (P : PredName) (ds : List D),
(P, ds.length) β hd.q.predVarSet β
((if h : (Ο P ds.length).isSome = true then
if ds.length = ((Ο P ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο P ds.length).get β―).1 ds) (hd :: tl) ((Ο P ds.length).get β―).2
else I.pred_var_ P ds
else I.pred_var_ P ds) β
I.pred_var_ P ds)
|
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ β (P : PredName) (ds : List D),
(P, ds.length) β β
β
((if h : (Ο P ds.length).isSome = true then
if ds.length = ((Ο P ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο P ds.length).get β―).1 ds) (hd :: tl) ((Ο P ds.length).get β―).2
else I.pred_var_ P ds
else I.pred_var_ P ds) β
I.pred_var_ P ds)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ β (P : PredName) (ds : List D),
(P, ds.length) β hd.q.predVarSet β
((if h : (Ο P ds.length).isSome = true then
if ds.length = ((Ο P ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο P ds.length).get β―).1 ds) (hd :: tl) ((Ο P ds.length).get β―).2
else I.pred_var_ P ds
else I.pred_var_ P ds) β
I.pred_var_ P ds)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp
|
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ β (P : PredName) (ds : List D),
(P, ds.length) β β
β
((if h : (Ο P ds.length).isSome = true then
if ds.length = ((Ο P ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο P ds.length).get β―).1 ds) (hd :: tl) ((Ο P ds.length).get β―).2
else I.pred_var_ P ds
else I.pred_var_ P ds) β
I.pred_var_ P ds)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : X = hd.name β§ xs.length = hd.args.length
β’ β (P : PredName) (ds : List D),
(P, ds.length) β β
β
((if h : (Ο P ds.length).isSome = true then
if ds.length = ((Ο P ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο P ds.length).get β―).1 ds) (hd :: tl) ((Ο P ds.length).get β―).2
else I.pred_var_ P ds
else I.pred_var_ P ds) β
I.pred_var_ P ds)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
apply Holds_coincide_PredVar
|
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V tl (def_ X xs) β
Holds D I V tl (def_ X xs)
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ { nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_const_ =
I.pred_const_
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ β (P : PredName) (ds : List D),
predVarOccursIn P ds.length (def_ X xs) β
({ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl)
((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_var_
P ds β
I.pred_var_ P ds)
|
Please generate a tactic in lean4 to solve the state.
STATE:
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ Holds D
{ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V tl (def_ X xs) β
Holds D I V tl (def_ X xs)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp
|
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ { nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_const_ =
I.pred_const_
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ { nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl) ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_const_ =
I.pred_const_
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp only [predVarOccursIn]
|
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ β (P : PredName) (ds : List D),
predVarOccursIn P ds.length (def_ X xs) β
({ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl)
((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_var_
P ds β
I.pred_var_ P ds)
|
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ β (P : PredName) (ds : List D),
False β
((if h : (Ο P ds.length).isSome = true then
if ds.length = ((Ο P ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο P ds.length).get β―).1 ds) (hd :: tl) ((Ο P ds.length).get β―).2
else I.pred_var_ P ds
else I.pred_var_ P ds) β
I.pred_var_ P ds)
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ β (P : PredName) (ds : List D),
predVarOccursIn P ds.length (def_ X xs) β
({ nonempty := β―, pred_const_ := I.pred_const_,
pred_var_ := fun X ds =>
if h : (Ο X ds.length).isSome = true then
if ds.length = ((Ο X ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X ds.length).get β―).1 ds) (hd :: tl)
((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }.pred_var_
P ds β
I.pred_var_ P ds)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/NV/Sub/Pred/All/Rec/Option/Sub.lean
|
FOL.NV.Sub.Pred.All.Rec.Option.substitution_theorem_aux
|
[90, 1]
|
[226, 15]
|
simp
|
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ β (P : PredName) (ds : List D),
False β
((if h : (Ο P ds.length).isSome = true then
if ds.length = ((Ο P ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο P ds.length).get β―).1 ds) (hd :: tl) ((Ο P ds.length).get β―).2
else I.pred_var_ P ds
else I.pred_var_ P ds) β
I.pred_var_ P ds)
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h2
D : Type
I : Interpretation D
V' : VarAssignment D
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ X xs)
h2 : β x β binders, V' x = V x
hd : Definition
tl : List Definition
c1 : Β¬(X = hd.name β§ xs.length = hd.args.length)
β’ β (P : PredName) (ds : List D),
False β
((if h : (Ο P ds.length).isSome = true then
if ds.length = ((Ο P ds.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο P ds.length).get β―).1 ds) (hd :: tl) ((Ο P ds.length).get β―).2
else I.pred_var_ P ds
else I.pred_var_ P ds) β
I.pred_var_ P ds)
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
ext cs
|
Ξ± : Type
R : RegExp Ξ±
β’ RegExp.languageOf Ξ± R.closure = RegExp.languageOf Ξ± (RegExp.epsilon.union (R.concat R.closure))
|
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ cs β RegExp.languageOf Ξ± R.closure β cs β RegExp.languageOf Ξ± (RegExp.epsilon.union (R.concat R.closure))
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
β’ RegExp.languageOf Ξ± R.closure = RegExp.languageOf Ξ± (RegExp.epsilon.union (R.concat R.closure))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
simp only [RegExp.languageOf]
|
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ cs β RegExp.languageOf Ξ± R.closure β cs β RegExp.languageOf Ξ± (RegExp.epsilon.union (R.concat R.closure))
|
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ cs β {l | β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = l} β
cs β
{[]} βͺ
{x |
β r β RegExp.languageOf Ξ± R,
β s β {l | β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = l}, r ++ s = x}
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ cs β RegExp.languageOf Ξ± R.closure β cs β RegExp.languageOf Ξ± (RegExp.epsilon.union (R.concat R.closure))
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
simp
|
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ cs β {l | β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = l} β
cs β
{[]} βͺ
{x |
β r β RegExp.languageOf Ξ± R,
β s β {l | β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = l}, r ++ s = x}
|
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ (β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs) β
cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ cs β {l | β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = l} β
cs β
{[]} βͺ
{x |
β r β RegExp.languageOf Ξ± R,
β s β {l | β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = l}, r ++ s = x}
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
constructor
|
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ (β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs) β
cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ (β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs) β
cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
case h.mpr
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ (cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs) β
β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ (β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs) β
cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
intro a1
|
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ (β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs) β
cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ (β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs) β
cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
apply Exists.elim a1
|
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
β’ β (a : List (List Ξ±)),
(β r β a, r β RegExp.languageOf Ξ± R) β§ a.join = cs β
cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
intro xs a2
|
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
β’ β (a : List (List Ξ±)),
(β r β a, r β RegExp.languageOf Ξ± R) β§ a.join = cs β
cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
xs : List (List Ξ±)
a2 : (β r β xs, r β RegExp.languageOf Ξ± R) β§ xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
β’ β (a : List (List Ξ±)),
(β r β a, r β RegExp.languageOf Ξ± R) β§ a.join = cs β
cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
clear a1
|
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
xs : List (List Ξ±)
a2 : (β r β xs, r β RegExp.languageOf Ξ± R) β§ xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
a2 : (β r β xs, r β RegExp.languageOf Ξ± R) β§ xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
xs : List (List Ξ±)
a2 : (β r β xs, r β RegExp.languageOf Ξ± R) β§ xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
cases a2
|
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
a2 : (β r β xs, r β RegExp.languageOf Ξ± R) β§ xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
case h.mp.intro
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
leftβ : β r β xs, r β RegExp.languageOf Ξ± R
rightβ : xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.mp
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
a2 : (β r β xs, r β RegExp.languageOf Ξ± R) β§ xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
case _ a2_left a2_right =>
simp only [β a2_right]
cases xs
case nil =>
left
simp
case cons hd tl =>
right
simp at a2_left
cases a2_left
case _ a2_left_left a2_left_right =>
apply Exists.intro hd
tauto
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
a2_left : β r β xs, r β RegExp.languageOf Ξ± R
a2_right : xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
a2_left : β r β xs, r β RegExp.languageOf Ξ± R
a2_right : xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
simp only [β a2_right]
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
a2_left : β r β xs, r β RegExp.languageOf Ξ± R
a2_right : xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
a2_left : β r β xs, r β RegExp.languageOf Ξ± R
a2_right : xs.join = cs
β’ xs.join = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = xs.join
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
a2_left : β r β xs, r β RegExp.languageOf Ξ± R
a2_right : xs.join = cs
β’ cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
cases xs
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
a2_left : β r β xs, r β RegExp.languageOf Ξ± R
a2_right : xs.join = cs
β’ xs.join = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = xs.join
|
case nil
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a2_left : β r β [], r β RegExp.languageOf Ξ± R
a2_right : [].join = cs
β’ [].join = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = [].join
case cons
Ξ± : Type
R : RegExp Ξ±
cs headβ : List Ξ±
tailβ : List (List Ξ±)
a2_left : β r β headβ :: tailβ, r β RegExp.languageOf Ξ± R
a2_right : (headβ :: tailβ).join = cs
β’ (headβ :: tailβ).join = [] β¨
β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (headβ :: tailβ).join
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
xs : List (List Ξ±)
a2_left : β r β xs, r β RegExp.languageOf Ξ± R
a2_right : xs.join = cs
β’ xs.join = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = xs.join
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
case nil =>
left
simp
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a2_left : β r β [], r β RegExp.languageOf Ξ± R
a2_right : [].join = cs
β’ [].join = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = [].join
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a2_left : β r β [], r β RegExp.languageOf Ξ± R
a2_right : [].join = cs
β’ [].join = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = [].join
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
case cons hd tl =>
right
simp at a2_left
cases a2_left
case _ a2_left_left a2_left_right =>
apply Exists.intro hd
tauto
|
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_left : β r β hd :: tl, r β RegExp.languageOf Ξ± R
a2_right : (hd :: tl).join = cs
β’ (hd :: tl).join = [] β¨
β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_left : β r β hd :: tl, r β RegExp.languageOf Ξ± R
a2_right : (hd :: tl).join = cs
β’ (hd :: tl).join = [] β¨
β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
left
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a2_left : β r β [], r β RegExp.languageOf Ξ± R
a2_right : [].join = cs
β’ [].join = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = [].join
|
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a2_left : β r β [], r β RegExp.languageOf Ξ± R
a2_right : [].join = cs
β’ [].join = []
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a2_left : β r β [], r β RegExp.languageOf Ξ± R
a2_right : [].join = cs
β’ [].join = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = [].join
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
simp
|
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a2_left : β r β [], r β RegExp.languageOf Ξ± R
a2_right : [].join = cs
β’ [].join = []
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a2_left : β r β [], r β RegExp.languageOf Ξ± R
a2_right : [].join = cs
β’ [].join = []
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
right
|
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_left : β r β hd :: tl, r β RegExp.languageOf Ξ± R
a2_right : (hd :: tl).join = cs
β’ (hd :: tl).join = [] β¨
β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
|
case h
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_left : β r β hd :: tl, r β RegExp.languageOf Ξ± R
a2_right : (hd :: tl).join = cs
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_left : β r β hd :: tl, r β RegExp.languageOf Ξ± R
a2_right : (hd :: tl).join = cs
β’ (hd :: tl).join = [] β¨
β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
simp at a2_left
|
case h
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_left : β r β hd :: tl, r β RegExp.languageOf Ξ± R
a2_right : (hd :: tl).join = cs
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
|
case h
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
a2_left : hd β RegExp.languageOf Ξ± R β§ β a β tl, a β RegExp.languageOf Ξ± R
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_left : β r β hd :: tl, r β RegExp.languageOf Ξ± R
a2_right : (hd :: tl).join = cs
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
cases a2_left
|
case h
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
a2_left : hd β RegExp.languageOf Ξ± R β§ β a β tl, a β RegExp.languageOf Ξ± R
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
|
case h.intro
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
leftβ : hd β RegExp.languageOf Ξ± R
rightβ : β a β tl, a β RegExp.languageOf Ξ± R
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
a2_left : hd β RegExp.languageOf Ξ± R β§ β a β tl, a β RegExp.languageOf Ξ± R
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
case _ a2_left_left a2_left_right =>
apply Exists.intro hd
tauto
|
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
a2_left_left : hd β RegExp.languageOf Ξ± R
a2_left_right : β a β tl, a β RegExp.languageOf Ξ± R
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
a2_left_left : hd β RegExp.languageOf Ξ± R
a2_left_right : β a β tl, a β RegExp.languageOf Ξ± R
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
apply Exists.intro hd
|
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
a2_left_left : hd β RegExp.languageOf Ξ± R
a2_left_right : β a β tl, a β RegExp.languageOf Ξ± R
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
|
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
a2_left_left : hd β RegExp.languageOf Ξ± R
a2_left_right : β a β tl, a β RegExp.languageOf Ξ± R
β’ hd β RegExp.languageOf Ξ± R β§ β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ hd ++ a.join = (hd :: tl).join
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
a2_left_left : hd β RegExp.languageOf Ξ± R
a2_left_right : β a β tl, a β RegExp.languageOf Ξ± R
β’ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = (hd :: tl).join
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
tauto
|
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
a2_left_left : hd β RegExp.languageOf Ξ± R
a2_left_right : β a β tl, a β RegExp.languageOf Ξ± R
β’ hd β RegExp.languageOf Ξ± R β§ β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ hd ++ a.join = (hd :: tl).join
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs hd : List Ξ±
tl : List (List Ξ±)
a2_right : (hd :: tl).join = cs
a2_left_left : hd β RegExp.languageOf Ξ± R
a2_left_right : β a β tl, a β RegExp.languageOf Ξ± R
β’ hd β RegExp.languageOf Ξ± R β§ β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ hd ++ a.join = (hd :: tl).join
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
intro a1
|
case h.mpr
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ (cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs) β
β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
|
case h.mpr
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
β’ (cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs) β
β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
cases a1
|
case h.mpr
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
|
case h.mpr.inl
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
hβ : cs = []
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
case h.mpr.inr
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
hβ : β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
case h.mpr
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
a1 : cs = [] β¨ β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
case _ left =>
apply Exists.intro []
simp
simp only [left]
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
left : cs = []
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
left : cs = []
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
case _ right =>
apply Exists.elim right
intro xs a2
clear right
cases a2
case _ a2_left a2_right =>
apply Exists.elim a2_right
intro ys a3
clear a2_right
cases a3
case _ a3_left a3_right =>
apply Exists.intro ([xs] ++ ys)
simp
tauto
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
right : β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
right : β r β RegExp.languageOf Ξ± R, β a, (β r β a, r β RegExp.languageOf Ξ± R) β§ r ++ a.join = cs
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
apply Exists.intro []
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
left : cs = []
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
left : cs = []
β’ (β r β [], r β RegExp.languageOf Ξ± R) β§ [].join = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
left : cs = []
β’ β rs, (β r β rs, r β RegExp.languageOf Ξ± R) β§ rs.join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
simp
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
left : cs = []
β’ (β r β [], r β RegExp.languageOf Ξ± R) β§ [].join = cs
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
left : cs = []
β’ [] = cs
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
left : cs = []
β’ (β r β [], r β RegExp.languageOf Ξ± R) β§ [].join = cs
TACTIC:
|
https://github.com/pthomas505/FOL.git
|
097a4abea51b641d144539b9a0f7516f3b9d818c
|
FOL/Parsing/RegExp.lean
|
equiv_language_of_closure
|
[36, 1]
|
[83, 18]
|
simp only [left]
|
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
left : cs = []
β’ [] = cs
|
no goals
|
Please generate a tactic in lean4 to solve the state.
STATE:
Ξ± : Type
R : RegExp Ξ±
cs : List Ξ±
left : cs = []
β’ [] = cs
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.