internlm/Lean-Github huggingface dataset:
Theorem: LN.HoldsShift
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
i : ℕ
a1 : occursFreeIn (bound_ i) F
⊢ shift D V d (bound_ i) =
    if Var.openList 0 [free_ z] (bound_ i) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ i))
Tactic:
cases i
Proof state after:
case zero
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
a1 : occursFreeIn (bound_ 0) F
⊢ shift D V d (bound_ 0) =
    if Var.openList 0 [free_ z] (bound_ 0) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ 0))

case succ
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
n✝ : ℕ
a1 : occursFreeIn (bound_ (n✝ + 1)) F
⊢ shift D V d (bound_ (n✝ + 1)) =
    if Var.openList 0 [free_ z] (bound_ (n✝ + 1)) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ (n✝ + 1)))
Theorem: LN.HoldsShift
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
a1 : occursFreeIn (bound_ 0) F
⊢ shift D V d (bound_ 0) =
    if Var.openList 0 [free_ z] (bound_ 0) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ 0))
Tactic:
case zero =>
  simp only [shift]
  simp only [Var.openList]
  simp
Proof state after:
no goals
Theorem: LN.HoldsShift
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
i : ℕ
a1 : occursFreeIn (bound_ (i + 1)) F
⊢ shift D V d (bound_ (i + 1)) =
    if Var.openList 0 [free_ z] (bound_ (i + 1)) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ (i + 1)))
Tactic:
case succ i =>
  simp only [shift]
  simp only [Var.openList]
  simp
Proof state after:
no goals
Theorem: LN.HoldsShift
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
a1 : occursFreeIn (bound_ 0) F
⊢ shift D V d (bound_ 0) =
    if Var.openList 0 [free_ z] (bound_ 0) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ 0))
Tactic:
simp only [shift]
Proof state after:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
a1 : occursFreeIn (bound_ 0) F
⊢ d = if Var.openList 0 [free_ z] (bound_ 0) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ 0))
Theorem: LN.HoldsShift
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
a1 : occursFreeIn (bound_ 0) F
⊢ d = if Var.openList 0 [free_ z] (bound_ 0) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ 0))
Tactic:
simp only [Var.openList]
Proof state after:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
a1 : occursFreeIn (bound_ 0) F
⊢ d =
    if
        (if 0 < 0 then bound_ 0
          else if x : 0 - 0 < [free_ z].length then [free_ z][0 - 0] else bound_ (0 - 0 - [free_ z].length + 0)) =
          free_ z then
      d
    else
      V
        (if 0 < 0 then bound_ 0
        else if x : 0 - 0 < [free_ z].length then [free_ z][0 - 0] else bound_ (0 - 0 - [free_ z].length + 0))
Theorem: LN.HoldsShift
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
a1 : occursFreeIn (bound_ 0) F
⊢ d =
    if
        (if 0 < 0 then bound_ 0
          else if x : 0 - 0 < [free_ z].length then [free_ z][0 - 0] else bound_ (0 - 0 - [free_ z].length + 0)) =
          free_ z then
      d
    else
      V
        (if 0 < 0 then bound_ 0
        else if x : 0 - 0 < [free_ z].length then [free_ z][0 - 0] else bound_ (0 - 0 - [free_ z].length + 0))
Tactic:
simp
Proof state after:
no goals
Theorem: LN.HoldsShift
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
i : ℕ
a1 : occursFreeIn (bound_ (i + 1)) F
⊢ shift D V d (bound_ (i + 1)) =
    if Var.openList 0 [free_ z] (bound_ (i + 1)) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ (i + 1)))
Tactic:
simp only [shift]
Proof state after:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
i : ℕ
a1 : occursFreeIn (bound_ (i + 1)) F
⊢ V (bound_ i) =
    if Var.openList 0 [free_ z] (bound_ (i + 1)) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ (i + 1)))
Theorem: LN.HoldsShift
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
i : ℕ
a1 : occursFreeIn (bound_ (i + 1)) F
⊢ V (bound_ i) =
    if Var.openList 0 [free_ z] (bound_ (i + 1)) = free_ z then d else V (Var.openList 0 [free_ z] (bound_ (i + 1)))
Tactic:
simp only [Var.openList]
Proof state after:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
i : ℕ
a1 : occursFreeIn (bound_ (i + 1)) F
⊢ V (bound_ i) =
    if
        (if i + 1 < 0 then bound_ (i + 1)
          else
            if x : i + 1 - 0 < [free_ z].length then [free_ z][i + 1 - 0]
            else bound_ (i + 1 - 0 - [free_ z].length + 0)) =
          free_ z then
      d
    else
      V
        (if i + 1 < 0 then bound_ (i + 1)
        else
          if x : i + 1 - 0 < [free_ z].length then [free_ z][i + 1 - 0] else bound_ (i + 1 - 0 - [free_ z].length + 0))
Theorem: LN.HoldsShift
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
i : ℕ
a1 : occursFreeIn (bound_ (i + 1)) F
⊢ V (bound_ i) =
    if
        (if i + 1 < 0 then bound_ (i + 1)
          else
            if x : i + 1 - 0 < [free_ z].length then [free_ z][i + 1 - 0]
            else bound_ (i + 1 - 0 - [free_ z].length + 0)) =
          free_ z then
      d
    else
      V
        (if i + 1 < 0 then bound_ (i + 1)
        else
          if x : i + 1 - 0 < [free_ z].length then [free_ z][i + 1 - 0] else bound_ (i + 1 - 0 - [free_ z].length + 0))
Tactic:
simp
Proof state after:
no goals
Theorem: LN.HoldsForall
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
⊢ Holds D I V (forall_ x F) ↔ ∀ (d : D), Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Tactic:
simp only [Holds]
Proof state after:
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
⊢ (∀ (d : D), Holds D I (shift D V d) F) ↔
    ∀ (d : D), Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Theorem: LN.HoldsForall
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
⊢ (∀ (d : D), Holds D I (shift D V d) F) ↔
    ∀ (d : D), Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Tactic:
simp only [HoldsShift D I V F z h1]
Proof state after:
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
⊢ (∀ (d : D), Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 [free_ z]) F) ↔
    ∀ (d : D), Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Theorem: LN.HoldsForall
Proof state before:
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
⊢ (∀ (d : D), Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 [free_ z]) F) ↔
    ∀ (d : D), Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Tactic:
apply forall_congr'
Proof state after:
case h
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
⊢ ∀ (a : D),
    Holds D I (Function.updateITE V (free_ z) a ∘ Var.openList 0 [free_ z]) F ↔
      Holds D I (Function.updateITE V (free_ z) a) (Formula.openList 0 [free_ z] F)
Theorem: LN.HoldsForall
Proof state before:
case h
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
⊢ ∀ (a : D),
    Holds D I (Function.updateITE V (free_ z) a ∘ Var.openList 0 [free_ z]) F ↔
      Holds D I (Function.updateITE V (free_ z) a) (Formula.openList 0 [free_ z] F)
Tactic:
intro d
Proof state after:
case h
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
⊢ Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 [free_ z]) F ↔
    Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Theorem: LN.HoldsForall
Proof state before:
case h
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
⊢ Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 [free_ z]) F ↔
    Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Tactic:
obtain s1 := HoldsOpenList D I (Function.updateITE V (free_ z) d) 0 [z] F
Proof state after:
case h
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
s1 :
  Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 (List.map free_ [z])) F ↔
    Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 (List.map free_ [z]) F)
⊢ Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 [free_ z]) F ↔
    Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Theorem: LN.HoldsForall
Proof state before:
case h
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
s1 :
  Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 (List.map free_ [z])) F ↔
    Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 (List.map free_ [z]) F)
⊢ Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 [free_ z]) F ↔
    Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Tactic:
simp at s1
Proof state after:
case h
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
s1 :
  Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 [free_ z]) F ↔
    Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
⊢ Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 [free_ z]) F ↔
    Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Theorem: LN.HoldsForall
Proof state before:
case h
D : Type
I : Interpretation D
V : VarAssignment D
x : String
F : Formula
z : String
h1 : ¬occursFreeIn (free_ z) F
d : D
s1 :
  Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 [free_ z]) F ↔
    Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
⊢ Holds D I (Function.updateITE V (free_ z) d ∘ Var.openList 0 [free_ z]) F ↔
    Holds D I (Function.updateITE V (free_ z) d) (Formula.openList 0 [free_ z] F)
Tactic:
exact s1
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
⊢ shift D V d ∘ Var.close (j + 1) (free_ z) = shift D (V ∘ Var.close j (free_ z)) d
Tactic:
funext v
Proof state after:
case h
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
v : Var
⊢ (shift D V d ∘ Var.close (j + 1) (free_ z)) v = shift D (V ∘ Var.close j (free_ z)) d v
Theorem: LN.extracted_1
Proof state before:
case h
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
v : Var
⊢ (shift D V d ∘ Var.close (j + 1) (free_ z)) v = shift D (V ∘ Var.close j (free_ z)) d v
Tactic:
simp
Proof state after:
case h
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
v : Var
⊢ shift D V d (Var.close (j + 1) (free_ z) v) = shift D (V ∘ Var.close j (free_ z)) d v
Theorem: LN.extracted_1
Proof state before:
case h
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
v : Var
⊢ shift D V d (Var.close (j + 1) (free_ z) v) = shift D (V ∘ Var.close j (free_ z)) d v
Tactic:
cases v
Proof state after:
case h.free_
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
a✝ : String
⊢ shift D V d (Var.close (j + 1) (free_ z) (free_ a✝)) = shift D (V ∘ Var.close j (free_ z)) d (free_ a✝)

case h.bound_
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
a✝ : ℕ
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ a✝)) = shift D (V ∘ Var.close j (free_ z)) d (bound_ a✝)
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
⊢ shift D V d (Var.close (j + 1) (free_ z) (free_ x)) = shift D (V ∘ Var.close j (free_ z)) d (free_ x)
Tactic:
case _ x =>
  conv =>
    rhs
    simp only [shift]
    simp
  simp only [Var.close]
  simp
  split_ifs
  case _ c1 =>
    simp only [shift]
    simp
  case _ c1 =>
    simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ i)) = shift D (V ∘ Var.close j (free_ z)) d (bound_ i)
Tactic:
case _ i =>
  cases i
  case zero =>
    conv =>
      rhs
      simp only [shift]
    simp only [Var.close]
    simp
    simp only [shift]
  case succ i =>
    conv =>
      rhs
      simp only [shift]
      simp
      simp only [Var.close]
    simp only [Var.close]
    split
    case _ c1 =>
      have s1 : i < j
      linarith
      simp only [if_pos s1]
      simp only [shift]
    case _ c1 =>
      simp at c1
      have s1 : ¬ i < j
      linarith
      simp only [if_neg s1]
      simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
⊢ shift D V d (Var.close (j + 1) (free_ z) (free_ x)) = shift D (V ∘ Var.close j (free_ z)) d (free_ x)
Tactic:
conv =>
  rhs
  simp only [shift]
  simp
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
⊢ shift D V d (Var.close (j + 1) (free_ z) (free_ x)) = V (Var.close j (free_ z) (free_ x))
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
⊢ shift D V d (Var.close (j + 1) (free_ z) (free_ x)) = V (Var.close j (free_ z) (free_ x))
Tactic:
simp only [Var.close]
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
⊢ shift D V d (if free_ x = free_ z then bound_ (j + 1) else free_ x) =
    V (if free_ x = free_ z then bound_ j else free_ x)
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
⊢ shift D V d (if free_ x = free_ z then bound_ (j + 1) else free_ x) =
    V (if free_ x = free_ z then bound_ j else free_ x)
Tactic:
simp
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
⊢ shift D V d (if x = z then bound_ (j + 1) else free_ x) = V (if x = z then bound_ j else free_ x)
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
⊢ shift D V d (if x = z then bound_ (j + 1) else free_ x) = V (if x = z then bound_ j else free_ x)
Tactic:
split_ifs
Proof state after:
case pos
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
h✝ : x = z
⊢ shift D V d (bound_ (j + 1)) = V (bound_ j)

case neg
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
h✝ : ¬x = z
⊢ shift D V d (free_ x) = V (free_ x)
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
c1 : x = z
⊢ shift D V d (bound_ (j + 1)) = V (bound_ j)
Tactic:
case _ c1 =>
  simp only [shift]
  simp
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
c1 : ¬x = z
⊢ shift D V d (free_ x) = V (free_ x)
Tactic:
case _ c1 =>
  simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
c1 : x = z
⊢ shift D V d (bound_ (j + 1)) = V (bound_ j)
Tactic:
simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
x : String
c1 : ¬x = z
⊢ shift D V d (free_ x) = V (free_ x)
Tactic:
simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ i)) = shift D (V ∘ Var.close j (free_ z)) d (bound_ i)
Tactic:
cases i
Proof state after:
case zero
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ 0)) = shift D (V ∘ Var.close j (free_ z)) d (bound_ 0)

case succ
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
n✝ : ℕ
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ (n✝ + 1))) = shift D (V ∘ Var.close j (free_ z)) d (bound_ (n✝ + 1))
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ 0)) = shift D (V ∘ Var.close j (free_ z)) d (bound_ 0)
Tactic:
case zero =>
  conv =>
    rhs
    simp only [shift]
  simp only [Var.close]
  simp
  simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ (i + 1))) = shift D (V ∘ Var.close j (free_ z)) d (bound_ (i + 1))
Tactic:
case succ i =>
  conv =>
    rhs
    simp only [shift]
    simp
    simp only [Var.close]
  simp only [Var.close]
  split
  case _ c1 =>
    have s1 : i < j
    linarith
    simp only [if_pos s1]
    simp only [shift]
  case _ c1 =>
    simp at c1
    have s1 : ¬ i < j
    linarith
    simp only [if_neg s1]
    simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ 0)) = shift D (V ∘ Var.close j (free_ z)) d (bound_ 0)
Tactic:
conv =>
  rhs
  simp only [shift]
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ 0)) = d
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ 0)) = d
Tactic:
simp only [Var.close]
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
⊢ shift D V d (if 0 < j + 1 then bound_ 0 else bound_ (0 + 1)) = d
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
⊢ shift D V d (if 0 < j + 1 then bound_ 0 else bound_ (0 + 1)) = d
Tactic:
simp
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
⊢ shift D V d (bound_ 0) = d
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
⊢ shift D V d (bound_ 0) = d
Tactic:
simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ (i + 1))) = shift D (V ∘ Var.close j (free_ z)) d (bound_ (i + 1))
Tactic:
conv =>
  rhs
  simp only [shift]
  simp
  simp only [Var.close]
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ (i + 1))) = V (if i < j then bound_ i else bound_ (i + 1))
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
⊢ shift D V d (Var.close (j + 1) (free_ z) (bound_ (i + 1))) = V (if i < j then bound_ i else bound_ (i + 1))
Tactic:
simp only [Var.close]
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
⊢ shift D V d (if i + 1 < j + 1 then bound_ (i + 1) else bound_ (i + 1 + 1)) =
    V (if i < j then bound_ i else bound_ (i + 1))
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
⊢ shift D V d (if i + 1 < j + 1 then bound_ (i + 1) else bound_ (i + 1 + 1)) =
    V (if i < j then bound_ i else bound_ (i + 1))
Tactic:
split
Proof state after:
case inl
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
h✝ : i + 1 < j + 1
⊢ shift D V d (bound_ (i + 1)) = V (if i < j then bound_ i else bound_ (i + 1))

case inr
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
h✝ : ¬i + 1 < j + 1
⊢ shift D V d (bound_ (i + 1 + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : i + 1 < j + 1
⊢ shift D V d (bound_ (i + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Tactic:
case _ c1 =>
  have s1 : i < j
  linarith
  simp only [if_pos s1]
  simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : ¬i + 1 < j + 1
⊢ shift D V d (bound_ (i + 1 + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Tactic:
case _ c1 =>
  simp at c1
  have s1 : ¬ i < j
  linarith
  simp only [if_neg s1]
  simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : i + 1 < j + 1
⊢ shift D V d (bound_ (i + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Tactic:
have s1 : i < j
Proof state after:
case s1
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : i + 1 < j + 1
⊢ i < j

D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : i + 1 < j + 1
s1 : i < j
⊢ shift D V d (bound_ (i + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Theorem: LN.extracted_1
Proof state before:
case s1
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : i + 1 < j + 1
⊢ i < j

D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : i + 1 < j + 1
s1 : i < j
⊢ shift D V d (bound_ (i + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Tactic:
linarith
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : i + 1 < j + 1
s1 : i < j
⊢ shift D V d (bound_ (i + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : i + 1 < j + 1
s1 : i < j
⊢ shift D V d (bound_ (i + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Tactic:
simp only [if_pos s1]
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : i + 1 < j + 1
s1 : i < j
⊢ shift D V d (bound_ (i + 1)) = V (bound_ i)
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : i + 1 < j + 1
s1 : i < j
⊢ shift D V d (bound_ (i + 1)) = V (bound_ i)
Tactic:
simp only [shift]
Proof state after:
no goals
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : ¬i + 1 < j + 1
⊢ shift D V d (bound_ (i + 1 + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Tactic:
simp at c1
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : j ≤ i
⊢ shift D V d (bound_ (i + 1 + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Theorem: LN.extracted_1
Proof state before:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : j ≤ i
⊢ shift D V d (bound_ (i + 1 + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Tactic:
have s1 : ¬ i < j
Proof state after:
case s1
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : j ≤ i
⊢ ¬i < j

D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : j ≤ i
s1 : ¬i < j
⊢ shift D V d (bound_ (i + 1 + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Theorem: LN.extracted_1
Proof state before:
case s1
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : j ≤ i
⊢ ¬i < j

D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : j ≤ i
s1 : ¬i < j
⊢ shift D V d (bound_ (i + 1 + 1)) = V (if i < j then bound_ i else bound_ (i + 1))
Tactic:
linarith
Proof state after:
D : Type
V : VarAssignment D
j : ℕ
z : String
d : D
i : ℕ
c1 : j ≤ i
s1 : ¬i < j
⊢ shift D V d (bound_ (i + 1 + 1)) = V (if i < j then bound_ i else bound_ (i + 1))