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

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

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

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

State before:
j : ℕ
z : String
i : ℕ
⊢ (Var.open j (free_ z) (bound_ i)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
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
⊢ (Var.open j (free_ z) (free_ x)).freeVarSet ⊆ (free_ x).freeVarSet ∪ {free_ z}
Tactic:
simp only [Var.open]
State after:
j : ℕ
z x : String
⊢ (free_ x).freeVarSet ⊆ (free_ x).freeVarSet ∪ {free_ z}

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

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

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

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

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

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

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

State before:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : i = j
⊢ (free_ z).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
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 - 1)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
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 ∪ {free_ z}
Tactic:
simp only [Var.freeVarSet]
State after:
j : ℕ
z : String
i : ℕ
c1 : i < j
⊢ ∅ ⊆ ∅ ∪ {free_ z}

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

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

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

State before:
j : ℕ
z : String
i : ℕ
c1 : ¬i < j
c2 : ¬i = j
⊢ (bound_ (i - 1)).freeVarSet ⊆ (bound_ i).freeVarSet ∪ {free_ z}
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