internlm/Lean-Github huggingface dataset:
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
x : VarName
phi phi' : Formula
a✝ : IsSubAux (Function.updateITE σ' x x) (binders' ∪ {x}) phi phi'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
ih_2 :
  ∀ (V V' : VarAssignment D),
    (∀ (v : VarName), v ∈ binders' ∨ v = x → V v = V' (Function.updateITE σ' x x v)) →
      (∀ (v : VarName),
          Function.updateITE σ' x x v ∉ binders' →
            ¬Function.updateITE σ' x x v = x → V v = V' (Function.updateITE σ' x x v)) →
        (∀ (v : VarName), v ∈ binders' ∨ v = x → v = Function.updateITE σ' x x v) →
          (Holds D I V E phi ↔ Holds D I V' E phi')
s1 : ∀ (v : VarName), ¬v = x → v ∈ binders' → ¬σ' v = x
d : D
v : VarName
c1 : ¬v = x
c2 : v = x
⊢ v = σ' v
Tactic:
contradiction
Proof state after:
no goals
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
E : Env
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V E (def_ X' xs') ↔ Holds D I V' E (def_ X' (List.map σ' xs'))
Tactic:
induction E
Proof state after:
case nil
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V [] (def_ X' xs') ↔ Holds D I V' [] (def_ X' (List.map σ' xs'))

case cons
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
head✝ : Definition
tail✝ : List Definition
tail_ih✝ : Holds D I V tail✝ (def_ X' xs') ↔ Holds D I V' tail✝ (def_ X' (List.map σ' xs'))
⊢ Holds D I V (head✝ :: tail✝) (def_ X' xs') ↔ Holds D I V' (head✝ :: tail✝) (def_ X' (List.map σ' xs'))
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V [] (def_ X' xs') ↔ Holds D I V' [] (def_ X' (List.map σ' xs'))
Tactic:
case nil =>
  simp only [Holds]
Proof state after:
no goals
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
⊢ Holds D I V [] (def_ X' xs') ↔ Holds D I V' [] (def_ X' (List.map σ' xs'))
Tactic:
simp only [Holds]
Proof state after:
no goals
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
⊢ Holds D I V (hd :: tl) (def_ X' xs') ↔ Holds D I V' (hd :: tl) (def_ X' (List.map σ' xs'))
Tactic:
simp only [Holds]
Proof state after:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
⊢ (if X' = hd.name ∧ xs'.length = hd.args.length then
      Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q
    else Holds D I V tl (def_ X' xs')) ↔
    if X' = hd.name ∧ (List.map σ' xs').length = hd.args.length then
      Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q
    else Holds D I V' tl (def_ X' (List.map σ' xs'))
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : ¬(X' = hd.name ∧ (List.map σ' xs').length = hd.args.length)
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
Tactic:
case _ c1 c2 =>
  simp only [List.length_map] at c2
  contradiction
Proof state after:
no goals
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I V tl (def_ X' xs') ↔ Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q
Tactic:
case _ c1 c2 =>
  simp at c2
  contradiction
Proof state after:
no goals
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : ¬(X' = hd.name ∧ xs'.length = hd.args.length)
c2 : ¬(X' = hd.name ∧ (List.map σ' xs').length = hd.args.length)
⊢ Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
Tactic:
case _ c1 c2 =>
  exact ih
Proof state after:
no goals
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔
    Holds D I (Function.updateListITE V' hd.args (List.map V' (List.map σ' xs'))) tl hd.q
Tactic:
simp
Proof state after:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔
    Holds D I (Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs')) tl hd.q
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ Holds D I (Function.updateListITE V hd.args (List.map V xs')) tl hd.q ↔
    Holds D I (Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs')) tl hd.q
Tactic:
apply Holds_coincide_Var
Proof state after:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ ∀ (v : VarName),
    isFreeIn v hd.q →
      Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
⊢ ∀ (v : VarName),
    isFreeIn v hd.q →
      Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
intro v a1
Proof state after:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
have s1 : List.map V xs' = List.map (V' ∘ σ') xs'
Proof state after:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ List.map V xs' = List.map (V' ∘ σ') xs'

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ List.map V xs' = List.map (V' ∘ σ') xs'

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
simp only [List.map_eq_map_iff]
Proof state after:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ ∀ x ∈ xs', V x = (V' ∘ σ') x

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
⊢ ∀ x ∈ xs', V x = (V' ∘ σ') x

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
intro x a2
Proof state after:
case s1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
x : VarName
a2 : x ∈ xs'
⊢ V x = (V' ∘ σ') x

case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Theorem: FOL.NV.Sub.Var.All.Ind.substitution_theorem_aux
Proof state before:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map V xs') v = Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v
Tactic:
simp only [s1]
Proof state after:
case h1
D : Type
I : Interpretation D
σ : VarName → VarName
binders : Finset VarName
F F' : Formula
σ' : VarName → VarName
binders' : Finset VarName
X' : DefName
xs' : List VarName
ih_1 : ∀ v ∈ xs', v ∉ binders' → σ' v ∉ binders'
V V' : VarAssignment D
h2 : ∀ v ∈ binders', V v = V' (σ' v)
h3 : ∀ (v : VarName), σ' v ∉ binders' → V v = V' (σ' v)
h4 : ∀ v ∈ binders', v = σ' v
hd : Definition
tl : List Definition
ih : Holds D I V tl (def_ X' xs') ↔ Holds D I V' tl (def_ X' (List.map σ' xs'))
c1 : X' = hd.name ∧ xs'.length = hd.args.length
c2 : X' = hd.name ∧ (List.map σ' xs').length = hd.args.length
v : VarName
a1 : isFreeIn v hd.q
s1 : List.map V xs' = List.map (V' ∘ σ') xs'
⊢ Function.updateListITE V hd.args (List.map (V' ∘ σ') xs') v =
    Function.updateListITE V' hd.args (List.map (V' ∘ σ') xs') v