internlm/Lean-Github huggingface dataset:
Theorem: FOL.NV.Sub.Prop.All.Rec.substitution_is_valid
Proof state before:
F : Formula
τ : PredName → PredName
h1 : ∀ (D : Type) (I : Interpretation D) (V : VarAssignment D) (E : Env), Holds D I V E F
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
⊢ Holds D
    { nonempty := ⋯, pred_const_ := I.pred_const_,
      pred_var_ := fun P ds => if ds = [] then Holds D I V E (pred_var_ (τ P) []) else I.pred_var_ P ds }
    V E F
Tactic:
apply h1
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
E : Env
u v : VarName
F : Formula
a : D
h1 : ¬isFreeIn v F
h2 : ¬isBoundIn v F
⊢ Holds D I (Function.updateITE V u a) E F ↔
    Holds D I (Function.updateITE V v a) E (Sub.Var.One.Rec.fastReplaceFree u v F)
Tactic:
induction E generalizing F V
Proof state after:
case nil
D : Type
I : Interpretation D
u v : VarName
a : D
V : VarAssignment D
F : Formula
h1 : ¬isFreeIn v F
h2 : ¬isBoundIn v F
⊢ Holds D I (Function.updateITE V u a) [] F ↔
    Holds D I (Function.updateITE V v a) [] (Sub.Var.One.Rec.fastReplaceFree u v F)

case cons
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
F : Formula
h1 : ¬isFreeIn v F
h2 : ¬isBoundIn v F
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) F ↔
    Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v F)
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
X : DefName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (def_ X xs)
h2 : ¬isBoundIn v (def_ X xs)
⊢ Holds D I (Function.updateITE V u a) [] (def_ X xs) ↔
    Holds D I (Function.updateITE V v a) [] (Sub.Var.One.Rec.fastReplaceFree u v (def_ X xs))
Tactic:
case nil.def_ X xs =>
  simp only [Sub.Var.One.Rec.fastReplaceFree]
  simp only [Holds]
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (pred_var_ X xs)
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
    Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
Tactic:
case pred_const_ X xs | pred_var_ X xs =>
  simp only [isFreeIn] at h1
  simp only [Sub.Var.One.Rec.fastReplaceFree]
  simp only [Holds]
  congr! 1
  simp
  simp only [List.map_eq_map_iff]
  intro x a1
  simp
  simp only [Function.updateITE]
  simp only [eq_comm]
  split_ifs
  case _ c1 c2 =>
    rfl
  case _ c1 c2 =>
    contradiction
  case _ c1 c2 =>
    subst c2
    contradiction
  case _ c1 c2 =>
    rfl
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
V : VarAssignment D
h1 : ¬isFreeIn v false_
h2 : ¬isBoundIn v false_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) false_ ↔
    Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v false_)
Tactic:
case true_ | false_ =>
  simp only [Sub.Var.One.Rec.fastReplaceFree]
  simp only [Holds]
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
phi : Formula
phi_ih :
  ∀ (V : VarAssignment D),
    ¬isFreeIn v phi →
      ¬isBoundIn v phi →
        (Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi ↔
          Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi))
V : VarAssignment D
h1 : ¬isFreeIn v phi.not_
h2 : ¬isBoundIn v phi.not_
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) phi.not_ ↔
    Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v phi.not_)
Tactic:
case not_ phi phi_ih =>
  simp only [isFreeIn] at h1
  simp only [isBoundIn] at h2
  simp only [Sub.Var.One.Rec.fastReplaceFree]
  simp only [Holds]
  congr! 1
  exact phi_ih V h1 h2
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (pred_var_ X xs)
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
    Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
Tactic:
simp only [isFreeIn] at h1
Proof state after:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
    Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
    Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (Sub.Var.One.Rec.fastReplaceFree u v (pred_var_ X xs))
Tactic:
simp only [Sub.Var.One.Rec.fastReplaceFree]
Proof state after:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
    Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (pred_var_ X (List.map (fun x => if u = x then v else x) xs))
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ Holds D I (Function.updateITE V u a) (head✝ :: tail✝) (pred_var_ X xs) ↔
    Holds D I (Function.updateITE V v a) (head✝ :: tail✝) (pred_var_ X (List.map (fun x => if u = x then v else x) xs))
Tactic:
simp only [Holds]
Proof state after:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ I.pred_var_ X (List.map (Function.updateITE V u a) xs) ↔
    I.pred_var_ X (List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs))
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ I.pred_var_ X (List.map (Function.updateITE V u a) xs) ↔
    I.pred_var_ X (List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs))
Tactic:
congr! 1
Proof state after:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ List.map (Function.updateITE V u a) xs =
    List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs)
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ List.map (Function.updateITE V u a) xs =
    List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs)
Tactic:
simp
Proof state after:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ List.map (Function.updateITE V u a) xs = List.map (Function.updateITE V v a ∘ fun x => if u = x then v else x) xs
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ List.map (Function.updateITE V u a) xs = List.map (Function.updateITE V v a ∘ fun x => if u = x then v else x) xs
Tactic:
simp only [List.map_eq_map_iff]
Proof state after:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ ∀ x ∈ xs, Function.updateITE V u a x = (Function.updateITE V v a ∘ fun x => if u = x then v else x) x
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
⊢ ∀ x ∈ xs, Function.updateITE V u a x = (Function.updateITE V v a ∘ fun x => if u = x then v else x) x
Tactic:
intro x a1
Proof state after:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ Function.updateITE V u a x = (Function.updateITE V v a ∘ fun x => if u = x then v else x) x
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ Function.updateITE V u a x = (Function.updateITE V v a ∘ fun x => if u = x then v else x) x
Tactic:
simp
Proof state after:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ Function.updateITE V u a x = Function.updateITE V v a (if u = x then v else x)
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ Function.updateITE V u a x = Function.updateITE V v a (if u = x then v else x)
Tactic:
simp only [Function.updateITE]
Proof state after:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ (if x = u then a else V x) = if (if u = x then v else x) = v then a else V (if u = x then v else x)
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ (if x = u then a else V x) = if (if u = x then v else x) = v then a else V (if u = x then v else x)
Tactic:
simp only [eq_comm]
Proof state after:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ (if u = x then a else V x) = if v = if u = x then v else x then a else V (if u = x then v else x)
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case a.h.e'_4
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
⊢ (if u = x then a else V x) = if v = if u = x then v else x then a else V (if u = x then v else x)
Tactic:
split_ifs
Proof state after:
case pos
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
h✝¹ : u = x
h✝ : v = v
⊢ a = a

case neg
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
h✝¹ : u = x
h✝ : ¬v = v
⊢ a = V v

case pos
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
h✝¹ : ¬u = x
h✝ : v = x
⊢ V x = a

case neg
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
h✝¹ : ¬u = x
h✝ : ¬v = x
⊢ V x = V x
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : v = v
⊢ a = a
Tactic:
case _ c1 c2 =>
  rfl
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : ¬v = v
⊢ a = V v
Tactic:
case _ c1 c2 =>
  contradiction
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : ¬u = x
c2 : v = x
⊢ V x = a
Tactic:
case _ c1 c2 =>
  subst c2
  contradiction
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : ¬u = x
c2 : ¬v = x
⊢ V x = V x
Tactic:
case _ c1 c2 =>
  rfl
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : v = v
⊢ a = a
Tactic:
rfl
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
X : PredName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (pred_var_ X xs)
x : VarName
a1 : x ∈ xs
c1 : u = x
c2 : ¬v = v
⊢ a = V v
Tactic:
contradiction
Proof state after:
no goals