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

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

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

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

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

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

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

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

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

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

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

Proof state:
case ret.read
k✝ : Cont'
f✝ : Option Γ' → Λ'
⊢ Decidable (ret k✝ = 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 ret.read
k✝ : Cont'
f✝ : Option Γ' → Λ'
⊢ Decidable (ret k✝ = 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 ret.read.h
k✝ : Cont'
f✝ : Option Γ' → Λ'
⊢ ¬ret k✝ = read f✝

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

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

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

Proof state:
case ret.pred
k✝ : Cont'
q₁✝ q₂✝ : Λ'
⊢ Decidable (ret k✝ = 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 ret.pred
k✝ : Cont'
q₁✝ q₂✝ : Λ'
⊢ Decidable (ret k✝ = 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 ret.pred.h
k✝ : Cont'
q₁✝ q₂✝ : Λ'
⊢ ¬ret k✝ = pred q₁✝ q₂✝

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

Proof state:
case ret.ret
k✝¹ k✝ : Cont'
⊢ Decidable (ret k✝¹ = 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 ret.ret
k✝¹ k✝ : Cont'
⊢ Decidable (ret k✝¹ = 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 ret.ret.h
k✝¹ k✝ : Cont'
⊢ ¬ret k✝¹ = ret k✝

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

Proof state:
case ret.ret.h.refl
k✝ : Cont'
⊢ False

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

Proof state:
case move.move
p✝¹ : Γ' → Bool
k₁✝¹ k₂✝¹ : K'
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
⊢ Decidable (move p✝¹ k₁✝¹ k₂✝¹ q✝¹ = move p✝ k₁✝ k₂✝ q✝)
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✝)
case copy.copy
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (copy q✝¹ = copy q✝)
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✝)
case read.read
f✝¹ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (read f✝¹ = read f✝)
case succ.succ
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (succ q✝¹ = succ q✝)
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₂✝)
case ret.ret k✝¹ k✝ : Cont' ⊢ Decidable (ret k✝¹ = ret k✝)

Next tactic:
case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  

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

Next tactic:
case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    

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

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

Proof state:
p✝¹ : Γ' → Bool
k₁✝¹ k₂✝¹ : K'
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ Decidable (move p✝¹ k₁✝¹ k₂✝¹ q✝¹ = move p✝ k₁✝ k₂✝ q✝)

Next tactic:
exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by 

Proof state:
p✝¹ : Γ' → Bool
k₁✝¹ k₂✝¹ : K'
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ move p✝¹ k₁✝¹ k₂✝¹ q✝¹ = move p✝ k₁✝ k₂✝ q✝ ↔ ?m.250101

Next tactic:
simp [Function.funext_iff]
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; 

Proof state:
p✝¹ : Γ' → Bool
k₁✝¹ k₂✝¹ : K'
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ (∀ (a : Γ'), p✝¹ a = p✝ a) ∧ k₁✝¹ = k₁✝ ∧ k₂✝¹ = k₂✝ ∧ q✝¹ = q✝ ↔ ?m.250101

Next tactic:
rfl
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

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✝)
case copy.copy
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (copy q✝¹ = copy q✝)
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✝)
case read.read
f✝¹ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (read f✝¹ = read f✝)
case succ.succ
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (succ q✝¹ = succ q✝)
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₂✝)
case ret.ret k✝¹ k✝ : Cont' ⊢ Decidable (ret k✝¹ = ret k✝)

Next tactic:
case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

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

Next tactic:
case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    

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

Next tactic:
letI := I
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    

Proof state:
p✝¹ : Γ' → Bool
k✝¹ : K'
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ Decidable (clear p✝¹ k✝¹ q✝¹ = clear p✝ k✝ q✝)

Next tactic:
exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by 

Proof state:
p✝¹ : Γ' → Bool
k✝¹ : K'
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ clear p✝¹ k✝¹ q✝¹ = clear p✝ k✝ q✝ ↔ ?m.252077

Next tactic:
simp [Function.funext_iff]
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; 

Proof state:
p✝¹ : Γ' → Bool
k✝¹ : K'
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ (∀ (a : Γ'), p✝¹ a = p✝ a) ∧ k✝¹ = k✝ ∧ q✝¹ = q✝ ↔ ?m.252077

Next tactic:
rfl
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

Proof state:
case copy.copy
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (copy q✝¹ = copy q✝)
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✝)
case read.read
f✝¹ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (read f✝¹ = read f✝)
case succ.succ
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (succ q✝¹ = succ q✝)
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₂✝)
case ret.ret k✝¹ k✝ : Cont' ⊢ Decidable (ret k✝¹ = ret k✝)

Next tactic:
case copy.copy _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

Proof state:
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (copy q✝¹ = copy q✝)

Next tactic:
case copy.copy _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case copy.copy _ I _ =>
    

Proof state:
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (copy q✝¹ = copy q✝)

Next tactic:
letI := I
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case copy.copy _ I _ =>
    letI := I
    

Proof state:
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ Decidable (copy q✝¹ = copy q✝)

Next tactic:
exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case copy.copy _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by 

Proof state:
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ copy q✝¹ = copy q✝ ↔ ?m.253971

Next tactic:
simp [Function.funext_iff]
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case copy.copy _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; 

Proof state:
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ q✝¹ = q✝ ↔ ?m.253971

Next tactic:
rfl
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case copy.copy _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

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✝)
case read.read
f✝¹ : Option Γ' → Λ'
f_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)
f✝ : Option Γ' → Λ'
⊢ Decidable (read f✝¹ = read f✝)
case succ.succ
q✝¹ : Λ'
q_ih✝ : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (succ q✝¹ = succ q✝)
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₂✝)
case ret.ret k✝¹ k✝ : Cont' ⊢ Decidable (ret k✝¹ = ret k✝)

Next tactic:
case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case copy.copy _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

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

Next tactic:
case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case copy.copy _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case push.push _ _ _ I _ _ _ =>
    

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

Next tactic:
letI := I
instance Λ'.instDecidableEq : DecidableEq Λ' := fun a b => by
  induction a generalizing b <;> cases b <;> try apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done
  case move.move _ _ _ _ I _ _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case clear.clear _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case copy.copy _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    

Proof state:
k✝¹ : K'
s✝¹ : Option Γ' → Option Γ'
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ Decidable (push k✝¹ s✝¹ q✝¹ = push k✝ s✝ q✝)

Next tactic:
exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)