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
|
|---|---|---|---|---|---|---|---|---|
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux | [129, 1] | [273, 17] | exact h2 x c3 | case pos
D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : X' = hd.name β§ xs'.length = hd.args.length
c2 : X' = hd.name β§ (List.map Ο' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x β xs'
c3 : x β binders'
β’ V x = (V' β Ο') x | no goals |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux | [129, 1] | [273, 17] | apply h3 x | case neg
D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : X' = hd.name β§ xs'.length = hd.args.length
c2 : X' = hd.name β§ (List.map Ο' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x β xs'
c3 : x β binders'
β’ V x = (V' β Ο') x | case neg
D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : X' = hd.name β§ xs'.length = hd.args.length
c2 : X' = hd.name β§ (List.map Ο' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x β xs'
c3 : x β binders'
β’ Ο' x β binders' |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux | [129, 1] | [273, 17] | apply ih_1 x a2 c3 | case neg
D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : X' = hd.name β§ xs'.length = hd.args.length
c2 : X' = hd.name β§ (List.map Ο' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x β xs'
c3 : x β binders'
β’ Ο' x β binders' | no goals |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux | [129, 1] | [273, 17] | simp only [List.length_map] at c2 | D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : X' = hd.name β§ xs'.length = hd.args.length
c2 : Β¬(X' = hd.name β§ (List.map Ο' xs').length = hd.args.length)
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q β Holds D I V' tl (def_ X' (List.map Ο' xs')) | D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : X' = hd.name β§ xs'.length = hd.args.length
c2 : Β¬(X' = hd.name β§ xs'.length = hd.args.length)
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q β Holds D I V' tl (def_ X' (List.map Ο' xs')) |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux | [129, 1] | [273, 17] | contradiction | D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : X' = hd.name β§ xs'.length = hd.args.length
c2 : Β¬(X' = hd.name β§ xs'.length = hd.args.length)
β’ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q β Holds D I V' tl (def_ X' (List.map Ο' xs')) | no goals |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux | [129, 1] | [273, 17] | simp at c2 | D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : Β¬(X' = hd.name β§ xs'.length = hd.args.length)
c2 : X' = hd.name β§ (List.map Ο' xs').length = hd.args.length
β’ Holds D I V tl (def_ X' xs') β Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map Ο' xs'))) tl hd.q | D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : Β¬(X' = hd.name β§ xs'.length = hd.args.length)
c2 : X' = hd.name β§ xs'.length = hd.args.length
β’ Holds D I V tl (def_ X' xs') β Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map Ο' xs'))) tl hd.q |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux | [129, 1] | [273, 17] | contradiction | D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : Β¬(X' = hd.name β§ xs'.length = hd.args.length)
c2 : X' = hd.name β§ xs'.length = hd.args.length
β’ Holds D I V tl (def_ X' xs') β Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map Ο' xs'))) tl hd.q | no goals |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux | [129, 1] | [273, 17] | exact ih | D : Type
I : Interpretation D
Ο : VarName β VarName
binders : Finset VarName
F F' : Formula
Ο' : VarName β VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : β v β xs', v β binders' β Ο' v β binders'
V V' : VarAssignment D
h2 : β v β binders', V v = V' (Ο' v)
h3 : β (v : VarName), Ο' v β binders' β V v = V' (Ο' v)
h4 : β v β binders', v = Ο' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs'))
c1 : Β¬(X' = hd.name β§ xs'.length = hd.args.length)
c2 : Β¬(X' = hd.name β§ (List.map Ο' xs').length = hd.args.length)
β’ Holds D I V tl (def_ X' xs') β Holds D I V' tl (def_ X' (List.map Ο' xs')) | no goals |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem | [276, 1] | [289, 9] | apply substitution_theorem_aux D I (V β Ο) V E Ο β
F F' h1 | D : Type
I : Interpretation D
V : VarAssignment D
E : Env
Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
β’ Holds D I (V β Ο) E F β Holds D I V E F' | case h2
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
β’ β v β β
, (V β Ο) v = V (Ο v)
case h3
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
β’ β (v : VarName), Ο v β β
β (V β Ο) v = V (Ο v)
case h4
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
β’ β v β β
, v = Ο v |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem | [276, 1] | [289, 9] | simp | case h2
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
β’ β v β β
, (V β Ο) v = V (Ο v) | no goals |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem | [276, 1] | [289, 9] | simp | case h3
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
β’ β (v : VarName), Ο v β β
β (V β Ο) v = V (Ο v) | no goals |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_theorem | [276, 1] | [289, 9] | simp | case h4
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
β’ β v β β
, v = Ο v | no goals |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_is_valid | [292, 1] | [304, 11] | simp only [IsValid] at h2 | Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
h2 : F.IsValid
β’ F'.IsValid | Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
h2 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
β’ F'.IsValid |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_is_valid | [292, 1] | [304, 11] | simp only [IsValid] | Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
h2 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
β’ F'.IsValid | Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
h2 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
β’ β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F' |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_is_valid | [292, 1] | [304, 11] | intro D I V E | Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
h2 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
β’ β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F' | Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
h2 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
β’ Holds D I V E F' |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_is_valid | [292, 1] | [304, 11] | simp only [β substitution_theorem D I V E Ο F F' h1] | Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
h2 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
β’ Holds D I V E F' | Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
h2 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
β’ Holds D I (V β Ο) E F |
https://github.com/pthomas505/FOL.git | 097a4abea51b641d144539b9a0f7516f3b9d818c | FOL/NV/Sub/Var/All/Ind/Sub.lean | FOL.NV.Sub.Var.All.Ind.substitution_is_valid | [292, 1] | [304, 11] | apply h2 | Ο : VarName β VarName
F F' : Formula
h1 : IsSub Ο F F'
h2 : β (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
β’ Holds D I (V β Ο) E F | no goals |
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] | induction F generalizing binders V | D : Type
I : Interpretation D
V V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
binders : Finset VarName
F : Formula
h1 : admitsAux Ο binders F
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 F β
Holds D I V E (replace c Ο F) | case pred_const_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβΒΉ : PredName
aβ : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_const_ aβΒΉ aβ)
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 (pred_const_ aβΒΉ aβ) β
Holds D I V E (replace c Ο (pred_const_ aβΒΉ aβ))
case pred_var_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβΒΉ : PredName
aβ : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_var_ aβΒΉ aβ)
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 (pred_var_ aβΒΉ aβ) β
Holds D I V E (replace c Ο (pred_var_ aβΒΉ aβ))
case eq_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβΒΉ aβ : VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (eq_ aβΒΉ aβ)
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_ aβΒΉ aβ) β
Holds D I V E (replace c Ο (eq_ aβΒΉ aβ))
case true_
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 true_
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 true_ β
Holds D I V E (replace c Ο true_)
case 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 =>
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_)
case not_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβ : Formula
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β 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 aβ β
Holds D I V E (replace c Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders aβ.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 aβ.not_ β
Holds D I V E (replace c Ο aβ.not_)
case imp_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβΒΉ β
(β 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 aβΒΉ β
Holds D I V E (replace c Ο aβΒΉ))
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β 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 aβ β
Holds D I V E (replace c Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (aβΒΉ.imp_ aβ)
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 (aβΒΉ.imp_ aβ) β
Holds D I V E (replace c Ο (aβΒΉ.imp_ aβ))
case and_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβΒΉ β
(β 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 aβΒΉ β
Holds D I V E (replace c Ο aβΒΉ))
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β 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 aβ β
Holds D I V E (replace c Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (aβΒΉ.and_ aβ)
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 (aβΒΉ.and_ aβ) β
Holds D I V E (replace c Ο (aβΒΉ.and_ aβ))
case or_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβΒΉ β
(β 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 aβΒΉ β
Holds D I V E (replace c Ο aβΒΉ))
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β 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 aβ β
Holds D I V E (replace c Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (aβΒΉ.or_ aβ)
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 (aβΒΉ.or_ aβ) β
Holds D I V E (replace c Ο (aβΒΉ.or_ aβ))
case iff_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβΒΉ aβ : Formula
a_ihβΒΉ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβΒΉ β
(β 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 aβΒΉ β
Holds D I V E (replace c Ο aβΒΉ))
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β 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 aβ β
Holds D I V E (replace c Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (aβΒΉ.iff_ aβ)
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 (aβΒΉ.iff_ aβ) β
Holds D I V E (replace c Ο (aβΒΉ.iff_ aβ))
case forall_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβΒΉ : VarName
aβ : Formula
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β 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 aβ β
Holds D I V E (replace c Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (forall_ aβΒΉ aβ)
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 (forall_ aβΒΉ aβ) β
Holds D I V E (replace c Ο (forall_ aβΒΉ aβ))
case exists_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβΒΉ : VarName
aβ : Formula
a_ihβ :
β (V : VarAssignment D) (binders : Finset VarName),
admitsAux Ο binders aβ β
(β 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 aβ β
Holds D I V E (replace c Ο aβ))
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (exists_ aβΒΉ aβ)
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_ aβΒΉ aβ) β
Holds D I V E (replace c Ο (exists_ aβΒΉ aβ))
case def_
D : Type
I : Interpretation D
V' : VarAssignment D
E : Env
c : Char
Ο : PredName β β β Option (List VarName Γ Formula)
aβΒΉ : DefName
aβ : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (def_ aβΒΉ aβ)
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_ aβΒΉ aβ) β
Holds D I V E (replace c Ο (def_ aβΒΉ aβ)) |
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 pred_const_ X xs =>
simp only [replace]
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
h1 : admitsAux Ο binders (pred_const_ 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 (pred_const_ X xs) β
Holds D I V E (replace c Ο (pred_const_ X xs)) | no goals |
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 eq_ x y =>
simp only [replace]
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 =>
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)) | no goals |
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 true_ | false_ =>
simp only [replace]
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 =>
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_) | no goals |
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 not_ phi phi_ih =>
simp only [admitsAux] at h1
simp only [replace]
simp only [Holds]
congr! 1
exact phi_ih V binders h1 h2 | 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_) | no goals |
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 forall_ x phi phi_ih | exists_ x phi phi_ih =>
simp only [admitsAux] at h1
simp only [replace]
simp only [Holds]
first | apply forall_congr' | apply exists_congr
intro d
apply phi_ih (Function.updateITE V x d) (binders βͺ {x}) h1
intro v a1
simp only [Function.updateITE]
simp at a1
push_neg at a1
cases a1
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 (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)) | no goals |
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 : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_const_ 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 (pred_const_ X xs) β
Holds D I V E (replace c Ο (pred_const_ X xs)) | 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
h1 : admitsAux Ο binders (pred_const_ 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) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (pred_const_ X xs) β
Holds D I V E (pred_const_ X xs) |
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
h1 : admitsAux Ο binders (pred_const_ 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) E ((Ο X ds.length).get β―).2
else I.pred_var_ X ds
else I.pred_var_ X ds }
V E (pred_const_ X xs) β
Holds D I V E (pred_const_ X xs) | no goals |
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 : PredName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : admitsAux Ο binders (pred_var_ 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 (pred_var_ X xs) β
Holds D I V E (replace c Ο (pred_var_ X xs)) | 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
if xs.length = ((Ο X xs.length).get β―).1.length then
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
else True
β’ 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 (pred_var_ X xs) β
Holds D I V E (replace c Ο (pred_var_ X xs)) |
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 | 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
if xs.length = ((Ο X xs.length).get β―).1.length then
binders β© (((Ο X xs.length).get β―).2.freeVarSet \ ((Ο X xs.length).get β―).1.toFinset) = β
else True
else True
β’ 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 (pred_var_ X xs) β
Holds D I V E (replace c Ο (pred_var_ X xs)) | 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
β’ 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 (pred_var_ X xs) β
Holds D I V E (replace c Ο (pred_var_ X xs)) |
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 : 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
β’ 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 (pred_var_ X xs) β
Holds D I V E (replace c Ο (pred_var_ X xs)) | 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
β’ 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 (pred_var_ X xs) β
Holds D I V E
(if h : (Ο X xs.length).isSome = true then
if xs.length = ((Ο X xs.length).get β―).1.length then
Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2
else pred_var_ X xs
else pred_var_ X xs) |
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
β’ 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 (pred_var_ X xs) β
Holds D I V E
(if h : (Ο X xs.length).isSome = true then
if xs.length = ((Ο X xs.length).get β―).1.length then
Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2
else pred_var_ X xs
else pred_var_ X xs) | 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
β’ (if h : (Ο X (List.map V xs).length).isSome = true then
if (List.map V xs).length = ((Ο X (List.map V xs).length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X (List.map V xs).length).get β―).1 (List.map V xs)) E
((Ο X (List.map V xs).length).get β―).2
else I.pred_var_ X (List.map V xs)
else I.pred_var_ X (List.map V xs)) β
Holds D I V E
(if h : (Ο X xs.length).isSome = true then
if xs.length = ((Ο X xs.length).get β―).1.length then
Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2
else pred_var_ X xs
else pred_var_ X xs) |
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 | 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
β’ (if h : (Ο X (List.map V xs).length).isSome = true then
if (List.map V xs).length = ((Ο X (List.map V xs).length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X (List.map V xs).length).get β―).1 (List.map V xs)) E
((Ο X (List.map V xs).length).get β―).2
else I.pred_var_ X (List.map V xs)
else I.pred_var_ X (List.map V xs)) β
Holds D I V E
(if h : (Ο X xs.length).isSome = true then
if xs.length = ((Ο X xs.length).get β―).1.length then
Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2
else pred_var_ X xs
else pred_var_ X xs) | 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
β’ (if h : (Ο X xs.length).isSome = true then
if xs.length = ((Ο X xs.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2
else I.pred_var_ X (List.map V xs)
else I.pred_var_ X (List.map V xs)) β
Holds D I V E
(if h : (Ο X xs.length).isSome = true then
if xs.length = ((Ο X xs.length).get β―).1.length then
Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2
else pred_var_ X xs
else pred_var_ X xs) |
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
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
β’ (if h : (Ο X xs.length).isSome = true then
if xs.length = ((Ο X xs.length).get β―).1.length then
Holds D I (Function.updateListITE V' ((Ο X xs.length).get β―).1 (List.map V xs)) E ((Ο X xs.length).get β―).2
else I.pred_var_ X (List.map V xs)
else I.pred_var_ X (List.map V xs)) β
Holds D I V E
(if h : (Ο X xs.length).isSome = true then
if xs.length = ((Ο X xs.length).get β―).1.length then
Var.All.Rec.Fresh.sub (Function.updateListITE id ((Ο X xs.length).get β―).1 xs) c ((Ο X xs.length).get β―).2
else pred_var_ X xs
else pred_var_ X xs) | 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
hβΒΉ : (Ο X xs.length).isSome = true
hβ : xs.length = ((Ο X xs.length).get β―).1.length
β’ 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)
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
hβΒΉ : (Ο X xs.length).isSome = true
hβ : Β¬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)
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
hβ : Β¬(Ο X xs.length).isSome = true
β’ I.pred_var_ X (List.map V xs) β Holds D I V E (pred_var_ X xs) |
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 _ c1 c2 =>
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 |
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 _ c1 =>
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 |
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] | let opt := Ο X xs.length | 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
β’ 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
β’ 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) |
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] | let val := Option.get opt c1 | 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
β’ 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
β’ 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) |
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] | let zs := val.fst | 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
β’ 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
β’ 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) |
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] | let H := val.snd | 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
β’ 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
β’ 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) |
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) |
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) |
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) |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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) |
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 |
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_ |
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 |
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_) |
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_ |
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) |
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) |
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 |
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)) |
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)) |
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)) |
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)) |
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) |
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 |
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 |
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)) |
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)) |
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) |
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) |
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) |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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) |
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) |
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 |
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 |
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)) |
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 |
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) |
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 |
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) |
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) |
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) |
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) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.