l3lab/ntp-mathlib huggingface dataset:
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case push.pred
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (push k✝ s✝ q✝ = pred q₁✝ q₂✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case push.pred
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (push k✝ s✝ q✝ = pred q₁✝ q₂✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case push.pred.h
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ ¬push k✝ s✝ q✝ = pred q₁✝ q₂✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case push.ret
k✝¹ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ Decidable (push k✝¹ s✝ q✝ = ret k✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case push.ret
k✝¹ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ Decidable (push k✝¹ s✝ q✝ = ret k✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case push.ret.h
k✝¹ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ ¬push k✝¹ s✝ q✝ = ret k✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case read.move
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (read f✝ = move p✝ k₁✝ k₂✝ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case read.move
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (read f✝ = move p✝ k₁✝ k₂✝ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case read.move.h
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ ¬read f✝ = move p✝ k₁✝ k₂✝ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case read.clear
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (read f✝ = clear p✝ k✝ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case read.clear
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (read f✝ = clear p✝ k✝ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case read.clear.h
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ ¬read f✝ = clear p✝ k✝ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case read.copy
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
q✝ : Λ'
⊢ Decidable (read f✝ = copy q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case read.copy
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
q✝ : Λ'
⊢ Decidable (read f✝ = copy q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case read.copy.h
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
q✝ : Λ'
⊢ ¬read f✝ = copy q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case read.push
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (read f✝ = push k✝ s✝ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case read.push
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (read f✝ = push k✝ s✝ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case read.push.h
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ ¬read f✝ = push k✝ s✝ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case read.read
f✝¹ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (read f✝¹ = read f✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case read.read
f✝¹ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (read f✝¹ = read f✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case read.read.h
f✝¹ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)
f✝ : Option Γ' → Λ'
⊢ ¬read f✝¹ = read f✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; 

Proof state:
case read.read.h.refl
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
⊢ False

Next tactic:
done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case read.succ
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
q✝ : Λ'
⊢ Decidable (read f✝ = succ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case read.succ
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
q✝ : Λ'
⊢ Decidable (read f✝ = succ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case read.succ.h
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
q✝ : Λ'
⊢ ¬read f✝ = succ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case read.pred
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (read f✝ = pred q₁✝ q₂✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case read.pred
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (read f✝ = pred q₁✝ q₂✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case read.pred.h
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
q₁✝ q₂✝ : Λ'
⊢ ¬read f✝ = pred q₁✝ q₂✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case read.ret
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
k✝ : Cont'
⊢ Decidable (read f✝ = ret k✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case read.ret
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
k✝ : Cont'
⊢ Decidable (read f✝ = ret k✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case read.ret.h
f✝ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)
k✝ : Cont'
⊢ ¬read f✝ = ret k✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case succ.move
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (succ q✝¹ = move p✝ k₁✝ k₂✝ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case succ.move
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (succ q✝¹ = move p✝ k₁✝ k₂✝ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case succ.move.h
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ ¬succ q✝¹ = move p✝ k₁✝ k₂✝ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case succ.clear
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (succ q✝¹ = clear p✝ k✝ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case succ.clear
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (succ q✝¹ = clear p✝ k✝ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case succ.clear.h
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ ¬succ q✝¹ = clear p✝ k✝ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case succ.copy
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (succ q✝¹ = copy q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case succ.copy
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (succ q✝¹ = copy q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case succ.copy.h
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ ¬succ q✝¹ = copy q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case succ.push
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (succ q✝¹ = push k✝ s✝ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case succ.push
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (succ q✝¹ = push k✝ s✝ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case succ.push.h
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ ¬succ q✝¹ = push k✝ s✝ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case succ.read
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (succ q✝ = read f✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case succ.read
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (succ q✝ = read f✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case succ.read.h
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ ¬succ q✝ = read f✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case succ.succ
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (succ q✝¹ = succ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case succ.succ
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (succ q✝¹ = succ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case succ.succ.h
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ ¬succ q✝¹ = succ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; 

Proof state:
case succ.succ.h.refl
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
⊢ False

Next tactic:
done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case succ.pred
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (succ q✝ = pred q₁✝ q₂✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case succ.pred
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (succ q✝ = pred q₁✝ q₂✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case succ.pred.h
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ ¬succ q✝ = pred q₁✝ q₂✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case succ.ret
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ Decidable (succ q✝ = ret k✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case succ.ret
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ Decidable (succ q✝ = ret k✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case succ.ret.h
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ ¬succ q✝ = ret k✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case pred.move
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (pred q₁✝ q₂✝ = move p✝ k₁✝ k₂✝ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case pred.move
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (pred q₁✝ q₂✝ = move p✝ k₁✝ k₂✝ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case pred.move.h
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ ¬pred q₁✝ q₂✝ = move p✝ k₁✝ k₂✝ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case pred.clear
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (pred q₁✝ q₂✝ = clear p✝ k✝ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case pred.clear
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (pred q₁✝ q₂✝ = clear p✝ k✝ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case pred.clear.h
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ ¬pred q₁✝ q₂✝ = clear p✝ k✝ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case pred.copy
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
q✝ : Λ'
⊢ Decidable (pred q₁✝ q₂✝ = copy q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case pred.copy
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
q✝ : Λ'
⊢ Decidable (pred q₁✝ q₂✝ = copy q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case pred.copy.h
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
q✝ : Λ'
⊢ ¬pred q₁✝ q₂✝ = copy q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case pred.push
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (pred q₁✝ q₂✝ = push k✝ s✝ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case pred.push
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (pred q₁✝ q₂✝ = push k✝ s✝ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case pred.push.h
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ ¬pred q₁✝ q₂✝ = push k✝ s✝ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case pred.read
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (pred q₁✝ q₂✝ = read f✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case pred.read
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (pred q₁✝ q₂✝ = read f✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case pred.read.h
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
f✝ : Option Γ' → Λ'
⊢ ¬pred q₁✝ q₂✝ = read f✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case pred.succ
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
q✝ : Λ'
⊢ Decidable (pred q₁✝ q₂✝ = succ q✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case pred.succ
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
q✝ : Λ'
⊢ Decidable (pred q₁✝ q₂✝ = succ q✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case pred.succ.h
q₁✝ q₂✝ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)
q✝ : Λ'
⊢ ¬pred q₁✝ q₂✝ = succ q✝

Next tactic:
rintro ⟨⟨⟩⟩
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> 

Proof state:
case pred.pred
q₁✝¹ q₂✝¹ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝¹ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝¹ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (pred q₁✝¹ q₂✝¹ = pred q₁✝ q₂✝)

Next tactic:
try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try 

Proof state:
case pred.pred
q₁✝¹ q₂✝¹ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝¹ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝¹ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (pred q₁✝¹ q₂✝¹ = pred q₁✝ q₂✝)

Next tactic:
apply Decidable.isFalse
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; 

Proof state:
case pred.pred.h
q₁✝¹ q₂✝¹ : Λ'
q₁_ih✝ : (b : Λ') → Decidable (q₁✝¹ = b)
q₂_ih✝ : (b : Λ') → Decidable (q₂✝¹ = b)
q₁✝ q₂✝ : Λ'
⊢ ¬pred q₁✝¹ q₂✝¹ = pred q₁✝ q₂✝

Next tactic:
rintro ⟨⟨⟩⟩