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

Proof state:
case move.succ
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (move p✝ k₁✝ k₂✝ 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 move.succ.h
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ ¬move p✝ k₁✝ k₂✝ q✝¹ = succ q✝

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

Proof state:
case move.pred
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (move p✝ k₁✝ k₂✝ 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 move.pred
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (move p✝ k₁✝ k₂✝ 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 move.pred.h
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ ¬move p✝ k₁✝ k₂✝ q✝ = pred q₁✝ q₂✝

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

Proof state:
case move.ret
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ Decidable (move p✝ k₁✝ k₂✝ 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 move.ret
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ Decidable (move p✝ k₁✝ k₂✝ 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 move.ret.h
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ ¬move p✝ k₁✝ k₂✝ q✝ = ret k✝

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

Proof state:
case clear.move
p✝¹ : Γ' → Bool
k✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (clear p✝¹ k✝ 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 clear.move
p✝¹ : Γ' → Bool
k✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (clear p✝¹ k✝ 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 clear.move.h
p✝¹ : Γ' → Bool
k✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ ¬clear p✝¹ k✝ 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 clear.clear
p✝¹ : Γ' → Bool
k✝¹ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (clear p✝¹ k✝¹ 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 clear.clear
p✝¹ : Γ' → Bool
k✝¹ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (clear p✝¹ k✝¹ 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 clear.clear.h
p✝¹ : Γ' → Bool
k✝¹ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ ¬clear p✝¹ k✝¹ q✝¹ = clear p✝ k✝ 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 clear.clear.h.refl
p✝ : Γ' → Bool
k✝ : K'
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 clear.copy
p✝ : Γ' → Bool
k✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (clear p✝ k✝ 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 clear.copy
p✝ : Γ' → Bool
k✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (clear p✝ k✝ 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 clear.copy.h
p✝ : Γ' → Bool
k✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ ¬clear p✝ k✝ q✝¹ = copy q✝

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

Proof state:
case clear.push
p✝ : Γ' → Bool
k✝¹ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (clear p✝ k✝¹ 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 clear.push
p✝ : Γ' → Bool
k✝¹ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (clear p✝ k✝¹ 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 clear.push.h
p✝ : Γ' → Bool
k✝¹ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ ¬clear p✝ k✝¹ q✝¹ = push k✝ s✝ q✝

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

Proof state:
case clear.read
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (clear p✝ k✝ 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 clear.read
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (clear p✝ k✝ 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 clear.read.h
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ ¬clear p✝ k✝ q✝ = read f✝

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

Proof state:
case clear.succ
p✝ : Γ' → Bool
k✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (clear p✝ k✝ 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 clear.succ
p✝ : Γ' → Bool
k✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (clear p✝ k✝ 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 clear.succ.h
p✝ : Γ' → Bool
k✝ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ ¬clear p✝ k✝ q✝¹ = succ q✝

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

Proof state:
case clear.pred
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (clear p✝ k✝ 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 clear.pred
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (clear p✝ k✝ 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 clear.pred.h
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ ¬clear p✝ k✝ q✝ = pred q₁✝ q₂✝

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

Proof state:
case clear.ret
p✝ : Γ' → Bool
k✝¹ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ Decidable (clear p✝ k✝¹ 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 clear.ret
p✝ : Γ' → Bool
k✝¹ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ Decidable (clear p✝ k✝¹ 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 clear.ret.h
p✝ : Γ' → Bool
k✝¹ : K'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ ¬clear p✝ k✝¹ q✝ = ret k✝

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

Proof state:
case copy.move
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (copy 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 copy.move
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (copy 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 copy.move.h
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ ¬copy 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 copy.clear
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (copy 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 copy.clear
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (copy 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 copy.clear.h
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ ¬copy q✝¹ = clear p✝ k✝ q✝

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

Proof state:
case copy.copy
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (copy 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 copy.copy
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (copy 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 copy.copy.h
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ ¬copy q✝¹ = copy 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 copy.copy.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 copy.push
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (copy 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 copy.push
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (copy 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 copy.push.h
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ ¬copy q✝¹ = push k✝ s✝ q✝

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

Proof state:
case copy.read
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (copy 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 copy.read
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (copy 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 copy.read.h
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ ¬copy q✝ = read f✝

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

Proof state:
case copy.succ
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (copy 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 copy.succ
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (copy 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 copy.succ.h
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ ¬copy q✝¹ = succ q✝

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

Proof state:
case copy.pred
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (copy 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 copy.pred
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (copy 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 copy.pred.h
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
q₁✝ q₂✝ : Λ'
⊢ ¬copy q✝ = pred q₁✝ q₂✝

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

Proof state:
case copy.ret
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ Decidable (copy 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 copy.ret
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ Decidable (copy 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 copy.ret.h
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
k✝ : Cont'
⊢ ¬copy q✝ = ret k✝

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

Proof state:
case push.move
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (push k✝ s✝ 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 push.move
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (push k✝ s✝ 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 push.move.h
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ ¬push k✝ s✝ 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 push.clear
k✝¹ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (push k✝¹ s✝ 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 push.clear
k✝¹ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ Decidable (push k✝¹ s✝ 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 push.clear.h
k✝¹ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
⊢ ¬push k✝¹ s✝ q✝¹ = clear p✝ k✝ q✝

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

Proof state:
case push.copy
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (push k✝ s✝ 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 push.copy
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (push k✝ s✝ 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 push.copy.h
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ ¬push k✝ s✝ q✝¹ = copy q✝

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

Proof state:
case push.push
k✝¹ : K'
s✝¹ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (push k✝¹ s✝¹ 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 push.push
k✝¹ : K'
s✝¹ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ Decidable (push k✝¹ s✝¹ 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 push.push.h
k✝¹ : K'
s✝¹ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
⊢ ¬push k✝¹ s✝¹ q✝¹ = push k✝ s✝ 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 push.push.h.refl
k✝ : K'
s✝ : Option Γ' → Option Γ'
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 push.read
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (push k✝ s✝ 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 push.read
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (push k✝ s✝ 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 push.read.h
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝ = b)
f✝ : Option Γ' → Λ'
⊢ ¬push k✝ s✝ q✝ = read f✝

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

Proof state:
case push.succ
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (push k✝ s✝ 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 push.succ
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (push k✝ s✝ 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 push.succ.h
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ ¬push k✝ s✝ q✝¹ = succ q✝

Next tactic:
rintro ⟨⟨⟩⟩