internlm/Lean-Github huggingface dataset:
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs

case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
      (List.map (fun c => if v = c then V' t else V c) xs) v' =
    Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
Tactic:
{
  simp only [List.map_eq_map_iff]
  intro x a2
  simp
  split_ifs
  case _ c2 =>
    apply h2
    subst c2
    exact h1 a2
  case _ c2 =>
    rfl
}
Proof state after:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
      (List.map (fun c => if v = c then V' t else V c) xs) v' =
    Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
      (List.map (fun c => if v = c then V' t else V c) xs) v' =
    Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
Tactic:
simp only [s1]
Proof state after:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
      (List.map (V ∘ fun x => if v = x then t else x) xs) v' =
    Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ Function.updateListITE (fun c => if v = c then V' t else V c) hd.args
      (List.map (V ∘ fun x => if v = x then t else x) xs) v' =
    Function.updateListITE V hd.args (List.map (V ∘ fun x => if v = x then t else x) xs) v'
Tactic:
apply Function.updateListITE_mem_eq_len
Proof state after:
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ v' ∈ hd.args

case h1.h2
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ hd.args.length = (List.map (V ∘ fun x => if v = x then t else x) xs).length
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
Tactic:
simp only [List.map_eq_map_iff]
Proof state after:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ ∀ x ∈ xs, (if v = x then V' t else V x) = (V ∘ fun x => if v = x then t else x) x
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
⊢ ∀ x ∈ xs, (if v = x then V' t else V x) = (V ∘ fun x => if v = x then t else x) x
Tactic:
intro x a2
Proof state after:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
⊢ (if v = x then V' t else V x) = (V ∘ fun x => if v = x then t else x) x
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
⊢ (if v = x then V' t else V x) = (V ∘ fun x => if v = x then t else x) x
Tactic:
simp
Proof state after:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
⊢ (if v = x then V' t else V x) = V (if v = x then t else x)
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case s1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
⊢ (if v = x then V' t else V x) = V (if v = x then t else x)
Tactic:
split_ifs
Proof state after:
case pos
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
h✝ : v = x
⊢ V' t = V t

case neg
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
h✝ : ¬v = x
⊢ V x = V x
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ V' t = V t
Tactic:
case _ c2 =>
  apply h2
  subst c2
  exact h1 a2
Proof state after:
no goals
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : ¬v = x
⊢ V x = V x
Tactic:
case _ c2 =>
  rfl
Proof state after:
no goals
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ V' t = V t
Tactic:
apply h2
Proof state after:
case a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ t ∉ binders
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : v = x
⊢ t ∉ binders
Tactic:
subst c2
Proof state after:
case a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
a2 : v ∈ xs
⊢ t ∉ binders
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case a
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
a2 : v ∈ xs
⊢ t ∉ binders
Tactic:
exact h1 a2
Proof state after:
no goals
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
x : VarName
a2 : x ∈ xs
c2 : ¬v = x
⊢ V x = V x
Tactic:
rfl
Proof state after:
no goals
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
a1 : isFreeIn v' hd.q
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
⊢ v' ∈ hd.args
Tactic:
simp only [isFreeIn_iff_mem_freeVarSet] at a1
Proof state after:
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
a1 : v' ∈ hd.q.freeVarSet
⊢ v' ∈ hd.args
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
a1 : v' ∈ hd.q.freeVarSet
⊢ v' ∈ hd.args
Tactic:
simp only [← List.mem_toFinset]
Proof state after:
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
a1 : v' ∈ hd.q.freeVarSet
⊢ v' ∈ hd.args.toFinset
Theorem: FOL.NV.Sub.Var.One.Rec.substitution_theorem_aux
Proof state before:
case h1.h1
D : Type
I : Interpretation D
V' : VarAssignment D
v t : VarName
hd : Definition
tl : List Definition
ih :
  ∀ (V : VarAssignment D) (binders : Finset VarName) (F : Formula),
    fastAdmitsAux v t binders F →
      (∀ v ∉ binders, V' v = V v) →
        (Holds D I (Function.updateITE V v (V' t)) tl F ↔ Holds D I V tl (fastReplaceFree v t F))
X : DefName
xs : List VarName
V : VarAssignment D
binders : Finset VarName
h1 : v ∈ xs → t ∉ binders
h2 : ∀ v ∉ binders, V' v = V v
c1 : X = hd.name ∧ (List.map (fun x => if v = x then t else x) xs).length = hd.args.length
v' : VarName
s1 : List.map (fun x => if v = x then V' t else V x) xs = List.map (V ∘ fun x => if v = x then t else x) xs
a1 : v' ∈ hd.q.freeVarSet
⊢ v' ∈ hd.args.toFinset
Tactic:
exact Finset.mem_of_subset hd.h1 a1
Proof state after:
no goals