internlm/Lean-Github huggingface dataset:
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 : VarName
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 : v ≠ x → ¬isFreeIn v phi
h2_left : v ≠ x
h2_right : ¬isBoundIn v phi
c1 : ¬u = x
⊢ (∀ (d : D), Holds D I (Function.updateITE (Function.updateITE V u a) x d) (head✝ :: tail✝) phi) ↔
    ∀ (d : D),
      Holds D I (Function.updateITE (Function.updateITE V v a) x d) (head✝ :: tail✝)
        (Sub.Var.One.Rec.fastReplaceFree u v phi)
Tactic:
apply forall_congr'
Proof state after:
case h
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 : VarName
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 : v ≠ x → ¬isFreeIn v phi
h2_left : v ≠ x
h2_right : ¬isBoundIn v phi
c1 : ¬u = x
⊢ ∀ (a_1 : D),
    Holds D I (Function.updateITE (Function.updateITE V u a) x a_1) (head✝ :: tail✝) phi ↔
      Holds D I (Function.updateITE (Function.updateITE V v a) x a_1) (head✝ :: tail✝)
        (Sub.Var.One.Rec.fastReplaceFree u v phi)
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 : VarName
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 : v ≠ x → ¬isFreeIn v phi
h2_left : v ≠ x
h2_right : ¬isBoundIn v phi
c1 : ¬u = x
⊢ (∃ d, Holds D I (Function.updateITE (Function.updateITE V u a) x d) (head✝ :: tail✝) phi) ↔
    ∃ d,
      Holds D I (Function.updateITE (Function.updateITE V v a) x d) (head✝ :: tail✝)
        (Sub.Var.One.Rec.fastReplaceFree u v phi)
Tactic:
apply exists_congr
Proof state after:
case h
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 : VarName
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 : v ≠ x → ¬isFreeIn v phi
h2_left : v ≠ x
h2_right : ¬isBoundIn v phi
c1 : ¬u = x
⊢ ∀ (a_1 : D),
    Holds D I (Function.updateITE (Function.updateITE V u a) x a_1) (head✝ :: tail✝) phi ↔
      Holds D I (Function.updateITE (Function.updateITE V v a) x a_1) (head✝ :: tail✝)
        (Sub.Var.One.Rec.fastReplaceFree u v phi)
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case h.h1
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x : VarName
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 : v ≠ x → ¬isFreeIn v phi
h2_left : v ≠ x
h2_right : ¬isBoundIn v phi
c1 : ¬u = x
d : D
⊢ ¬isFreeIn v phi
Tactic:
exact h1 h2_left
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case h.h2
D : Type
I : Interpretation D
u v : VarName
a : D
head✝ : Definition
tail✝ : List Definition
tail_ih✝ :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tail✝ F ↔
          Holds D I (Function.updateITE V v a) tail✝ (Sub.Var.One.Rec.fastReplaceFree u v F))
x : VarName
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 : v ≠ x → ¬isFreeIn v phi
h2_left : v ≠ x
h2_right : ¬isBoundIn v phi
c1 : ¬u = x
d : D
⊢ ¬isBoundIn v phi
Tactic:
exact h2_right
Proof state after:
no goals
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:
simp only [Sub.Var.One.Rec.fastReplaceFree]
Proof state after:
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) [] (def_ 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
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) [] (def_ X (List.map (fun x => if u = x then v else x) xs))
Tactic:
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
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
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) (hd :: tl) (def_ X xs) ↔
    Holds D I (Function.updateITE V v a) (hd :: tl) (Sub.Var.One.Rec.fastReplaceFree u v (def_ X xs))
Tactic:
simp only [Sub.Var.One.Rec.fastReplaceFree]
Proof state after:
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
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) (hd :: tl) (def_ X xs) ↔
    Holds D I (Function.updateITE V v a) (hd :: tl) (def_ 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
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
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) (hd :: tl) (def_ X xs) ↔
    Holds D I (Function.updateITE V v a) (hd :: tl) (def_ 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
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (def_ X xs)
h2 : ¬isBoundIn v (def_ X xs)
⊢ (if X = hd.name ∧ xs.length = hd.args.length then
      Holds D I (Function.updateListITE (Function.updateITE V u a) hd.args (List.map (Function.updateITE V u a) xs)) tl
        hd.q
    else Holds D I (Function.updateITE V u a) tl (def_ X xs)) ↔
    if X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length then
      Holds D I
        (Function.updateListITE (Function.updateITE V v a) hd.args
          (List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs)))
        tl hd.q
    else Holds D I (Function.updateITE V v a) tl (def_ 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
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (def_ X xs)
h2 : ¬isBoundIn v (def_ X xs)
⊢ (if X = hd.name ∧ xs.length = hd.args.length then
      Holds D I (Function.updateListITE (Function.updateITE V u a) hd.args (List.map (Function.updateITE V u a) xs)) tl
        hd.q
    else Holds D I (Function.updateITE V u a) tl (def_ X xs)) ↔
    if X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length then
      Holds D I
        (Function.updateListITE (Function.updateITE V v a) hd.args
          (List.map (Function.updateITE V v a) (List.map (fun x => if u = x then v else x) xs)))
        tl hd.q
    else Holds D I (Function.updateITE V v a) tl (def_ X (List.map (fun x => if u = x then v else x) xs))
Tactic:
unfold Function.updateITE
Proof state after:
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (def_ X xs)
h2 : ¬isBoundIn v (def_ X xs)
⊢ (if X = hd.name ∧ xs.length = hd.args.length then
      Holds D I
        (Function.updateListITE (fun c => if c = u then a else V c) hd.args
          (List.map (fun c => if c = u then a else V c) xs))
        tl hd.q
    else Holds D I (fun c => if c = u then a else V c) tl (def_ X xs)) ↔
    if X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length then
      Holds D I
        (Function.updateListITE (fun c => if c = v then a else V c) hd.args
          (List.map (fun c => if c = v then a else V c) (List.map (fun x => if u = x then v else x) xs)))
        tl hd.q
    else Holds D I (fun c => if c = v then a else V c) tl (def_ 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
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (def_ X xs)
h2 : ¬isBoundIn v (def_ X xs)
⊢ X = hd.name ∧ xs.length = hd.args.length ↔
    X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
Tactic:
case _ =>
  simp
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (def_ X xs)
h2 : ¬isBoundIn v (def_ X xs)
⊢ X = hd.name ∧ xs.length = hd.args.length ↔
    X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
Tactic:
simp
Proof state after:
no goals
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : ¬isFreeIn v (def_ X xs)
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
⊢ Holds D I
      (Function.updateListITE (fun c => if c = u then a else V c) hd.args
        (List.map (fun c => if c = u then a else V c) xs))
      tl hd.q ↔
    Holds D I
      (Function.updateListITE (fun c => if c = v then a else V c) hd.args
        (List.map (fun c => if c = v then a else V c) (List.map (fun x => if u = x then v else x) xs)))
      tl hd.q
Tactic:
simp only [isFreeIn] at h1
Proof state after:
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
⊢ Holds D I
      (Function.updateListITE (fun c => if c = u then a else V c) hd.args
        (List.map (fun c => if c = u then a else V c) xs))
      tl hd.q ↔
    Holds D I
      (Function.updateListITE (fun c => if c = v then a else V c) hd.args
        (List.map (fun c => if c = v then a else V c) (List.map (fun x => if u = x then v else x) xs)))
      tl hd.q
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
⊢ Holds D I
      (Function.updateListITE (fun c => if c = u then a else V c) hd.args
        (List.map (fun c => if c = u then a else V c) xs))
      tl hd.q ↔
    Holds D I
      (Function.updateListITE (fun c => if c = v then a else V c) hd.args
        (List.map (fun c => if c = v then a else V c) (List.map (fun x => if u = x then v else x) xs)))
      tl hd.q
Tactic:
apply Holds_coincide_Var
Proof state after:
case h1
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
⊢ ∀ (v_1 : VarName),
    isFreeIn v_1 hd.q →
      Function.updateListITE (fun c => if c = u then a else V c) hd.args
          (List.map (fun c => if c = u then a else V c) xs) v_1 =
        Function.updateListITE (fun c => if c = v then a else V c) hd.args
          (List.map (fun c => if c = v then a else V c) (List.map (fun x => if u = x then v else x) xs)) v_1
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case h1
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
⊢ ∀ (v_1 : VarName),
    isFreeIn v_1 hd.q →
      Function.updateListITE (fun c => if c = u then a else V c) hd.args
          (List.map (fun c => if c = u then a else V c) xs) v_1 =
        Function.updateListITE (fun c => if c = v then a else V c) hd.args
          (List.map (fun c => if c = v then a else V c) (List.map (fun x => if u = x then v else x) xs)) v_1
Tactic:
intro v' a1
Proof state after:
case h1
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if c = u then a else V c) hd.args (List.map (fun c => if c = u then a else V c) xs)
      v' =
    Function.updateListITE (fun c => if c = v then a else V c) hd.args
      (List.map (fun c => if c = v then a else V c) (List.map (fun x => if u = x then v else x) xs)) v'
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case h1
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if c = u then a else V c) hd.args (List.map (fun c => if c = u then a else V c) xs)
      v' =
    Function.updateListITE (fun c => if c = v then a else V c) hd.args
      (List.map (fun c => if c = v then a else V c) (List.map (fun x => if u = x then v else x) xs)) v'
Tactic:
simp
Proof state after:
case h1
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if c = u then a else V c) hd.args (List.map (fun c => if c = u then a else V c) xs)
      v' =
    Function.updateListITE (fun c => if c = v then a else V c) hd.args
      (List.map ((fun c => if c = v then a else V c) ∘ fun x => if u = x then v else x) xs) v'
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
case h1
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ Function.updateListITE (fun c => if c = u then a else V c) hd.args (List.map (fun c => if c = u then a else V c) xs)
      v' =
    Function.updateListITE (fun c => if c = v then a else V c) hd.args
      (List.map ((fun c => if c = v then a else V c) ∘ fun x => if u = x then v else x) xs) v'
Tactic:
have s1 : (List.map ((fun (a_1 : VarName) => if a_1 = v then a else V a_1) ∘ fun (x : VarName) => if u = x then v else x) xs) = (List.map (fun (a_1 : VarName) => if a_1 = u then a else V a_1) xs)
Proof state after:
case s1
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ List.map ((fun a_1 => if a_1 = v then a else V a_1) ∘ fun x => if u = x then v else x) xs =
    List.map (fun a_1 => if a_1 = u then a else V a_1) xs

case h1
D : Type
I : Interpretation D
u v : VarName
a : D
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (F : Formula),
    ¬isFreeIn v F →
      ¬isBoundIn v F →
        (Holds D I (Function.updateITE V u a) tl F ↔
          Holds D I (Function.updateITE V v a) tl (Sub.Var.One.Rec.fastReplaceFree u v F))
X : DefName
xs : List VarName
V : VarAssignment D
h1 : v ∉ xs
h2 : ¬isBoundIn v (def_ X xs)
c1 : X = hd.name ∧ (List.map (fun x => if u = x then v else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 :
  List.map ((fun a_1 => if a_1 = v then a else V a_1) ∘ fun x => if u = x then v else x) xs =
    List.map (fun a_1 => if a_1 = u then a else V a_1) xs
⊢ Function.updateListITE (fun c => if c = u then a else V c) hd.args (List.map (fun c => if c = u then a else V c) xs)
      v' =
    Function.updateListITE (fun c => if c = v then a else V c) hd.args
      (List.map ((fun c => if c = v then a else V c) ∘ fun x => if u = x then v else x) xs) v'