l3lab/ntp-mathlib huggingface dataset:
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
    exact decidable_of_iff' _ (by 

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
⊢ push k✝¹ s✝¹ q✝¹ = push k✝ s✝ q✝ ↔ ?m.255379

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]; rfl)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; 

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
⊢ k✝¹ = k✝ ∧ (∀ (a : Option Γ'), s✝¹ a = s✝ a) ∧ q✝¹ = q✝ ↔ ?m.255379

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)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

Proof state:
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 read.read _ 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 _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

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

Next tactic:
case read.read _ 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 _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    

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

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
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    

Proof state:
f✝¹ : Option Γ' → Λ'
I : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)
f✝ : Option Γ' → Λ'
this : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b) := I
⊢ Decidable (read f✝¹ = read f✝)

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 simp [Function.funext_iff]; rfl)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by 

Proof state:
f✝¹ : Option Γ' → Λ'
I : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)
f✝ : Option Γ' → Λ'
this : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b) := I
⊢ read f✝¹ = read f✝ ↔ ?m.257331

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]; rfl)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; 

Proof state:
f✝¹ : Option Γ' → Λ'
I : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)
f✝ : Option Γ' → Λ'
this : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b) := I
⊢ (∀ (a : Option Γ'), f✝¹ a = f✝ a) ↔ ?m.257331

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)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

Proof state:
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 succ.succ _ 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 _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

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

Next tactic:
case succ.succ _ 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 _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    

Proof state:
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
⊢ Decidable (succ q✝¹ = succ 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
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    

Proof state:
q✝¹ : Λ'
I : (b : Λ') → Decidable (q✝¹ = b)
q✝ : Λ'
this : (b : Λ') → Decidable (q✝¹ = b) := I
⊢ Decidable (succ q✝¹ = succ 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 simp [Function.funext_iff]; rfl)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by 

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

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]; rfl)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ 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.259158

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)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

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₂✝)
case ret.ret k✝¹ k✝ : Cont' ⊢ Decidable (ret k✝¹ = ret k✝)

Next tactic:
case pred.pred _ _ I₁ I₂ _ _ =>
    letI := 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 _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

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

Next tactic:
case pred.pred _ _ I₁ I₂ _ _ =>
    letI := 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 _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case pred.pred _ _ I₁ I₂ _ _ =>
    

Proof state:
q₁✝¹ q₂✝¹ : Λ'
I₁ : (b : Λ') → Decidable (q₁✝¹ = b)
I₂ : (b : Λ') → Decidable (q₂✝¹ = b)
q₁✝ q₂✝ : Λ'
⊢ Decidable (pred q₁✝¹ q₂✝¹ = pred q₁✝ 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
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case pred.pred _ _ I₁ I₂ _ _ =>
    letI := I₁
    

Proof state:
q₁✝¹ q₂✝¹ : Λ'
I₁ : (b : Λ') → Decidable (q₁✝¹ = b)
I₂ : (b : Λ') → Decidable (q₂✝¹ = b)
q₁✝ q₂✝ : Λ'
this : (b : Λ') → Decidable (q₁✝¹ = b) := I₁
⊢ Decidable (pred q₁✝¹ q₂✝¹ = pred q₁✝ 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
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case pred.pred _ _ I₁ I₂ _ _ =>
    letI := I₁
    letI := I₂
    

Proof state:
q₁✝¹ q₂✝¹ : Λ'
I₁ : (b : Λ') → Decidable (q₁✝¹ = b)
I₂ : (b : Λ') → Decidable (q₂✝¹ = b)
q₁✝ q₂✝ : Λ'
this✝ : (b : Λ') → Decidable (q₁✝¹ = b) := I₁
this : (b : Λ') → Decidable (q₂✝¹ = b) := I₂
⊢ Decidable (pred q₁✝¹ q₂✝¹ = pred q₁✝ 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 simp [Function.funext_iff]; rfl)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case pred.pred _ _ I₁ I₂ _ _ =>
    letI := I₁
    letI := I₂
    exact decidable_of_iff' _ (by 

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

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]; rfl)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case pred.pred _ _ I₁ I₂ _ _ =>
    letI := I₁
    letI := I₂
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; 

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

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)
  case push.push _ _ _ I _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case pred.pred _ _ I₁ I₂ _ _ =>
    letI := I₁
    letI := I₂
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

Proof state:
case ret.ret
k✝¹ k✝ : Cont'
⊢ Decidable (ret k✝¹ = ret k✝)

Next tactic:
case ret.ret _ _ =>
    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 _ _ _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case read.read _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case succ.succ _ I _ =>
    letI := I
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  case pred.pred _ _ I₁ I₂ _ _ =>
    letI := I₁
    letI := I₂
    exact decidable_of_iff' _ (by simp [Function.funext_iff]; rfl)
  

Proof state:
k✝¹ k✝ : Cont'
⊢ Decidable (ret k✝¹ = ret k✝)

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