Theorem: LN.VarOpenFreeVarSet' (FOL/LN/Paper.lean)

State before:
j : ℕ
z : String
v : Var
⊢ v.freeVarSet ⊆ (Var.open j (free_ z) v).freeVarSet
Tactic:
cases v
State after:
case free_
j : ℕ
z a✝ : String
⊢ (free_ a✝).freeVarSet ⊆ (Var.open j (free_ z) (free_ a✝)).freeVarSet

case bound_
j : ℕ
z : String
a✝ : ℕ
⊢ (bound_ a✝).freeVarSet ⊆ (Var.open j (free_ z) (bound_ a✝)).freeVarSet

State before:
j : ℕ
z x : String
⊢ (free_ x).freeVarSet ⊆ (Var.open j (free_ z) (free_ x)).freeVarSet
Tactic:
case free_ x =>
  simp only [Var.open]
  simp only [Var.freeVarSet]
  simp
State after:
no goals

State before:
j : ℕ
z : String
i : ℕ
⊢ (bound_ i).freeVarSet ⊆ (Var.open j (free_ z) (bound_ i)).freeVarSet
Tactic:
case bound_ i =>
  simp only [Var.open]
  split_ifs
  case _ c1 =>
    simp only [Var.freeVarSet]
    simp
  case _ c1 c2 =>
    simp only [Var.freeVarSet]
    simp
  case _ c1 c2 =>
    simp only [Var.freeVarSet]
    simp
State after:
no goals

State before:
j : ℕ
z x : String
⊢ (free_ x).freeVarSet ⊆ (Var.open j (free_ z) (free_ x)).freeVarSet
Tactic:
simp only [Var.open]
State after:
j : ℕ
z x : String
⊢ (free_ x).freeVarSet ⊆ (free_ x).freeVarSet

State before:
j : ℕ
z x : String
⊢ (free_ x).freeVarSet ⊆ (free_ x).freeVarSet
Tactic:
simp only [Var.freeVarSet]
State after:
j : ℕ
z x : String
⊢ {free_ x} ⊆ {free_ x}

State before:
j : ℕ
z x : String
⊢ {free_ x} ⊆ {free_ x}
Tactic:
simp
State after:
no goals

State before:
j : ℕ
z : String
i : ℕ
⊢ (bound_ i).freeVarSet ⊆ (Var.open j (free_ z) (bound_ i)).freeVarSet
Tactic:
simp only [Var.open]
State after:
j : ℕ
z : String
i : ℕ
⊢ (bound_ i).freeVarSet ⊆ (if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)).freeVarSet

State before:
j : ℕ
z : String
i : ℕ
⊢ (bound_ i).freeVarSet ⊆ (if i < j then bound_ i else if i = j then free_ z else bound_ (i - 1)).freeVarSet
Tactic:
split_ifs
State after:
case pos
j : ℕ
z : String
i : ℕ
h✝ : i < j
⊢ (bound_ i).freeVarSet ⊆ (bound_ i).freeVarSet

case pos
j : ℕ
z : String
i : ℕ
h✝¹ : ¬i < j
h✝ : i = j
⊢ (bound_ i).freeVarSet ⊆ (free_ z).freeVarSet

case neg
j : ℕ
z : String
i : ℕ
h✝¹ : ¬i < j
h✝ : ¬i = j
⊢ (bound_ i).freeVarSet ⊆ (bound_ (i - 1)).freeVarSet

State before:
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ (bound_ i).freeVarSet ⊆ (bound_ i).freeVarSet
Tactic:
case _ c1 =>
  simp only [Var.freeVarSet]
  simp
State after:
no goals

State before:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ (bound_ i).freeVarSet ⊆ (free_ z).freeVarSet
Tactic:
case _ c1 c2 =>
  simp only [Var.freeVarSet]
  simp
State after:
no goals

State before:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : ¬i = j
⊢ (bound_ i).freeVarSet ⊆ (bound_ (i - 1)).freeVarSet
Tactic:
case _ c1 c2 =>
  simp only [Var.freeVarSet]
  simp
State after:
no goals

State before:
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ (bound_ i).freeVarSet ⊆ (bound_ i).freeVarSet
Tactic:
simp only [Var.freeVarSet]
State after:
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ ∅ ⊆ ∅

State before:
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ ∅ ⊆ ∅
Tactic:
simp
State after:
no goals

State before:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ (bound_ i).freeVarSet ⊆ (free_ z).freeVarSet
Tactic:
simp only [Var.freeVarSet]
State after:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ ∅ ⊆ {free_ z}

State before:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ ∅ ⊆ {free_ z}
Tactic:
simp
State after:
no goals

State before:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : ¬i = j
⊢ (bound_ i).freeVarSet ⊆ (bound_ (i - 1)).freeVarSet
Tactic:
simp only [Var.freeVarSet]
State after:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : ¬i = j
⊢ ∅ ⊆ ∅

State before:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : ¬i = j
⊢ ∅ ⊆ ∅
Tactic:
simp
State after:
no goals