internlm/Lean-Github huggingface dataset:
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
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'
Tactic:
{
  simp only [List.map_eq_map_iff]
  intro x a2
  simp only [eq_comm]
  simp
  split_ifs
  case _ =>
    rfl
  case _ =>
    contradiction
  case _ c1 c2 =>
    subst c2
    contradiction
  case _ =>
    rfl
}
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
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'
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
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'
Tactic:
simp only [s1]
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
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 = u then a else V c) 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
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 = u then a else V c) xs)
      v'
Tactic:
apply Function.updateListITE_mem_eq_len
Proof state after:
case h1.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
⊢ v' ∈ hd.args

case h1.h2
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
⊢ hd.args.length = (List.map (fun c => if c = u then a else V c) xs).length
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
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
Tactic:
simp only [List.map_eq_map_iff]
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
⊢ ∀ x ∈ xs, ((fun a_1 => if a_1 = v then a else V a_1) ∘ fun x => if u = x then v else x) x = if x = u then a else V x
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
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
⊢ ∀ x ∈ xs, ((fun a_1 => if a_1 = v then a else V a_1) ∘ fun x => if u = x then v else x) x = if x = u then a else V x
Tactic:
intro x a2
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
x : VarName
a2 : x ∈ xs
⊢ ((fun a_1 => if a_1 = v then a else V a_1) ∘ fun x => if u = x then v else x) x = if x = u then a else V x
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
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
x : VarName
a2 : x ∈ xs
⊢ ((fun a_1 => if a_1 = v then a else V a_1) ∘ fun x => if u = x then v else x) x = if x = u then a else V x
Tactic:
simp only [eq_comm]
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
x : VarName
a2 : x ∈ xs
⊢ (if u = x then a else V x) = ((fun a_1 => if v = a_1 then a else V a_1) ∘ fun x => if u = x then v else x) x
Theorem: FOL.NV.replace_empty_Holds
Proof state before:
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
x : VarName
a2 : x ∈ xs
⊢ (if u = x then a else V x) = ((fun a_1 => if v = a_1 then a else V a_1) ∘ fun x => if u = x then v else x) x
Tactic:
simp
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
x : VarName
a2 : 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 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
x : VarName
a2 : 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
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
x : VarName
a2 : x ∈ xs
h✝¹ : u = x
h✝ : v = v
⊢ a = a

case neg
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
x : VarName
a2 : x ∈ xs
h✝¹ : u = x
h✝ : ¬v = v
⊢ a = V v

case pos
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
x : VarName
a2 : x ∈ xs
h✝¹ : ¬u = x
h✝ : v = x
⊢ V x = a

case neg
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
x : VarName
a2 : 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
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
x : VarName
a2 : x ∈ xs
h✝¹ : u = x
h✝ : v = v
⊢ a = a
Tactic:
case _ =>
  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
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
x : VarName
a2 : x ∈ xs
h✝¹ : u = x
h✝ : ¬v = v
⊢ a = V v
Tactic:
case _ =>
  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
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
x : VarName
a2 : 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
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
x : VarName
a2 : x ∈ xs
h✝¹ : ¬u = x
h✝ : ¬v = x
⊢ V x = V x
Tactic:
case _ =>
  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
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
x : VarName
a2 : x ∈ xs
h✝¹ : u = x
h✝ : 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
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
x : VarName
a2 : x ∈ xs
h✝¹ : u = x
h✝ : ¬v = v
⊢ a = V v
Tactic:
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
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
x : VarName
a2 : x ∈ xs
c1 : ¬u = x
c2 : v = x
⊢ V x = a
Tactic:
subst c2
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
v' : VarName
a1 : isFreeIn v' hd.q
a2 : v ∈ xs
c1 : ¬u = v
⊢ V v = a
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
v' : VarName
a1 : isFreeIn v' hd.q
a2 : v ∈ xs
c1 : ¬u = v
⊢ V v = a
Tactic:
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
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
x : VarName
a2 : x ∈ xs
h✝¹ : ¬u = x
h✝ : ¬v = x
⊢ V x = V x
Tactic:
rfl
Proof state after:
no goals