l3lab/ntp-mathlib huggingface dataset:
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    

Proof state:
case read
q' : Λ'
q : Option Γ' → Λ'
q_ih : ∀ (a : Option Γ'), q' ∈ trStmts₁ (q a) → trStmts₁ q' ⊆ trStmts₁ (q a)
s : Option Γ'
h : q' ∈ trStmts₁ (q s)
x : Λ'
h' : x ∈ trStmts₁ q'
⊢ x ∈ insert (Λ'.read q) (Finset.biUnion Finset.univ fun s => trStmts₁ (q s))

Next tactic:
simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    

Proof state:
case read
q' : Λ'
q : Option Γ' → Λ'
q_ih : ∀ (a : Option Γ'), q' ∈ trStmts₁ (q a) → trStmts₁ q' ⊆ trStmts₁ (q a)
s : Option Γ'
h : q' ∈ trStmts₁ (q s)
x : Λ'
h' : x ∈ trStmts₁ q'
⊢ x = Λ'.read q ∨ ∃ a, x ∈ trStmts₁ (q a)

Next tactic:
exact Or.inr ⟨_, q_ih s h h'⟩
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · 

Proof state:
case succ
q' q : Λ'
q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q
⊢ (q' = unrev q →
      insert (Λ'.move (fun x => false) rev main q) (trStmts₁ q) ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))) ∧
    (q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q)))

Next tactic:
constructor
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · 

Proof state:
case succ.left
q' q : Λ'
q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q
⊢ q' = unrev q →
    insert (Λ'.move (fun x => false) rev main q) (trStmts₁ q) ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))

Next tactic:
rintro rfl
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      

Proof state:
case succ.left
q : Λ'
q_ih : unrev q ∈ trStmts₁ q → trStmts₁ (unrev q) ⊆ trStmts₁ q
⊢ insert (Λ'.move (fun x => false) rev main q) (trStmts₁ q) ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))

Next tactic:
apply Finset.subset_insert
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · 

Proof state:
case succ.right
q' q : Λ'
q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q
⊢ q' ∈ trStmts₁ q → trStmts₁ q' ⊆ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))

Next tactic:
intro h x h'
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      

Proof state:
case succ.right
q' q : Λ'
q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q
h : q' ∈ trStmts₁ q
x : Λ'
h' : x ∈ trStmts₁ q'
⊢ x ∈ insert (Λ'.succ q) (insert (unrev q) (trStmts₁ q))

Next tactic:
simp only [Finset.mem_insert]
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      simp only [Finset.mem_insert]
      

Proof state:
case succ.right
q' q : Λ'
q_ih : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q
h : q' ∈ trStmts₁ q
x : Λ'
h' : x ∈ trStmts₁ q'
⊢ x = Λ'.succ q ∨ x = unrev q ∨ x ∈ trStmts₁ q

Next tactic:
exact Or.inr (Or.inr <| q_ih h h')
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      simp only [Finset.mem_insert]
      exact Or.inr (Or.inr <| q_ih h h')
  · 

Proof state:
case pred
q' q₁ q₂ : Λ'
q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁
q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂
⊢ (q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ∧
    (q' = unrev q₂ →
        insert (Λ'.move (fun x => false) rev main q₂) (trStmts₁ q₂) ⊆
          insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))) ∧
      (q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂)))

Next tactic:
refine' ⟨fun h x h' => _, fun _ x h' => _, fun h x h' => _⟩
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      simp only [Finset.mem_insert]
      exact Or.inr (Or.inr <| q_ih h h')
  · refine' ⟨fun h x h' => _, fun _ x h' => _, fun h x h' => _⟩ <;> 

Proof state:
case pred.refine'_1
q' q₁ q₂ : Λ'
q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁
q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂
h : q' ∈ trStmts₁ q₁
x : Λ'
h' : x ∈ trStmts₁ q'
⊢ x ∈ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))

Next tactic:
simp
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      simp only [Finset.mem_insert]
      exact Or.inr (Or.inr <| q_ih h h')
  · refine' ⟨fun h x h' => _, fun _ x h' => _, fun h x h' => _⟩ <;> 

Proof state:
case pred.refine'_2
q' q₁ q₂ : Λ'
q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁
q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂
x✝ : q' = unrev q₂
x : Λ'
h' : x ∈ insert (Λ'.move (fun x => false) rev main q₂) (trStmts₁ q₂)
⊢ x ∈ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))

Next tactic:
simp
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      simp only [Finset.mem_insert]
      exact Or.inr (Or.inr <| q_ih h h')
  · refine' ⟨fun h x h' => _, fun _ x h' => _, fun h x h' => _⟩ <;> 

Proof state:
case pred.refine'_3
q' q₁ q₂ : Λ'
q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁
q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂
h : q' ∈ trStmts₁ q₂
x : Λ'
h' : x ∈ trStmts₁ q'
⊢ x ∈ insert (Λ'.pred q₁ q₂) (trStmts₁ q₁ ∪ insert (unrev q₂) (trStmts₁ q₂))

Next tactic:
simp
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      simp only [Finset.mem_insert]
      exact Or.inr (Or.inr <| q_ih h h')
  · refine' ⟨fun h x h' => _, fun _ x h' => _, fun h x h' => _⟩ <;> simp
    · 

Proof state:
case pred.refine'_1
q' q₁ q₂ : Λ'
q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁
q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂
h : q' ∈ trStmts₁ q₁
x : Λ'
h' : x ∈ trStmts₁ q'
⊢ x = Λ'.pred q₁ q₂ ∨ x = unrev q₂ ∨ x ∈ trStmts₁ q₁ ∨ x ∈ trStmts₁ q₂

Next tactic:
exact Or.inr (Or.inr <| Or.inl <| q₁_ih h h')
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      simp only [Finset.mem_insert]
      exact Or.inr (Or.inr <| q_ih h h')
  · refine' ⟨fun h x h' => _, fun _ x h' => _, fun h x h' => _⟩ <;> simp
    · exact Or.inr (Or.inr <| Or.inl <| q₁_ih h h')
    · 

Proof state:
case pred.refine'_2
q' q₁ q₂ : Λ'
q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁
q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂
x✝ : q' = unrev q₂
x : Λ'
h' : x ∈ insert (Λ'.move (fun x => false) rev main q₂) (trStmts₁ q₂)
⊢ x = Λ'.pred q₁ q₂ ∨ x = unrev q₂ ∨ x ∈ trStmts₁ q₁ ∨ x ∈ trStmts₁ q₂

Next tactic:
cases' Finset.mem_insert.1 h' with h' h'
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      simp only [Finset.mem_insert]
      exact Or.inr (Or.inr <| q_ih h h')
  · refine' ⟨fun h x h' => _, fun _ x h' => _, fun h x h' => _⟩ <;> simp
    · exact Or.inr (Or.inr <| Or.inl <| q₁_ih h h')
    · cases' Finset.mem_insert.1 h' with h' h' <;> 

Proof state:
case pred.refine'_2.inl
q' q₁ q₂ : Λ'
q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁
q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂
x✝ : q' = unrev q₂
x : Λ'
h'✝ : x ∈ insert (Λ'.move (fun x => false) rev main q₂) (trStmts₁ q₂)
h' : x = Λ'.move (fun x => false) rev main q₂
⊢ x = Λ'.pred q₁ q₂ ∨ x = unrev q₂ ∨ x ∈ trStmts₁ q₁ ∨ x ∈ trStmts₁ q₂

Next tactic:
simp [h', unrev]
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      simp only [Finset.mem_insert]
      exact Or.inr (Or.inr <| q_ih h h')
  · refine' ⟨fun h x h' => _, fun _ x h' => _, fun h x h' => _⟩ <;> simp
    · exact Or.inr (Or.inr <| Or.inl <| q₁_ih h h')
    · cases' Finset.mem_insert.1 h' with h' h' <;> 

Proof state:
case pred.refine'_2.inr
q' q₁ q₂ : Λ'
q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁
q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂
x✝ : q' = unrev q₂
x : Λ'
h'✝ : x ∈ insert (Λ'.move (fun x => false) rev main q₂) (trStmts₁ q₂)
h' : x ∈ trStmts₁ q₂
⊢ x = Λ'.pred q₁ q₂ ∨ x = unrev q₂ ∨ x ∈ trStmts₁ q₁ ∨ x ∈ trStmts₁ q₂

Next tactic:
simp [h', unrev]
theorem trStmts₁_trans {q q'} : q' ∈ trStmts₁ q → trStmts₁ q' ⊆ trStmts₁ q := by
  induction' q with _ _ _ q q_ih _ _ q q_ih q q_ih _ _ q q_ih q q_ih q q_ih q₁ q₂ q₁_ih q₂_ih _ <;>
    simp (config := { contextual := true }) only [trStmts₁, Finset.mem_insert, Finset.mem_union,
      or_imp, Finset.mem_singleton, Finset.Subset.refl, imp_true_iff, true_and_iff]
  iterate 4 exact fun h => Finset.Subset.trans (q_ih h) (Finset.subset_insert _ _)
  · simp
    intro s h x h'
    simp only [Finset.mem_biUnion, Finset.mem_univ, true_and, Finset.mem_insert]
    exact Or.inr ⟨_, q_ih s h h'⟩
  · constructor
    · rintro rfl
      apply Finset.subset_insert
    · intro h x h'
      simp only [Finset.mem_insert]
      exact Or.inr (Or.inr <| q_ih h h')
  · refine' ⟨fun h x h' => _, fun _ x h' => _, fun h x h' => _⟩ <;> simp
    · exact Or.inr (Or.inr <| Or.inl <| q₁_ih h h')
    · cases' Finset.mem_insert.1 h' with h' h' <;> simp [h', unrev]
    · 

Proof state:
case pred.refine'_3
q' q₁ q₂ : Λ'
q₁_ih : q' ∈ trStmts₁ q₁ → trStmts₁ q' ⊆ trStmts₁ q₁
q₂_ih : q' ∈ trStmts₁ q₂ → trStmts₁ q' ⊆ trStmts₁ q₂
h : q' ∈ trStmts₁ q₂
x : Λ'
h' : x ∈ trStmts₁ q'
⊢ x = Λ'.pred q₁ q₂ ∨ x = unrev q₂ ∨ x ∈ trStmts₁ q₁ ∨ x ∈ trStmts₁ q₂

Next tactic:
exact Or.inr (Or.inr <| Or.inr <| q₂_ih h h')
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  

Proof state:
q : Λ'
⊢ q ∈ trStmts₁ q

Next tactic:
induction q
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · 

Proof state:
case move
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.move p✝ k₁✝ k₂✝ q✝ ∈ trStmts₁ (Λ'.move p✝ k₁✝ k₂✝ q✝)

Next tactic:
first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |

Proof state:
case move
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.move p✝ k₁✝ k₂✝ q✝ ∈ trStmts₁ (Λ'.move p✝ k₁✝ k₂✝ q✝)

Next tactic:
apply Finset.mem_singleton_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |apply Finset.mem_singleton_self|

Proof state:
case move
p✝ : Γ' → Bool
k₁✝ k₂✝ : K'
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.move p✝ k₁✝ k₂✝ q✝ ∈ trStmts₁ (Λ'.move p✝ k₁✝ k₂✝ q✝)

Next tactic:
apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · 

Proof state:
case clear
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.clear p✝ k✝ q✝ ∈ trStmts₁ (Λ'.clear p✝ k✝ q✝)

Next tactic:
first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |

Proof state:
case clear
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.clear p✝ k✝ q✝ ∈ trStmts₁ (Λ'.clear p✝ k✝ q✝)

Next tactic:
apply Finset.mem_singleton_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |apply Finset.mem_singleton_self|

Proof state:
case clear
p✝ : Γ' → Bool
k✝ : K'
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.clear p✝ k✝ q✝ ∈ trStmts₁ (Λ'.clear p✝ k✝ q✝)

Next tactic:
apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · 

Proof state:
case copy
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.copy q✝ ∈ trStmts₁ (Λ'.copy q✝)

Next tactic:
first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |

Proof state:
case copy
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.copy q✝ ∈ trStmts₁ (Λ'.copy q✝)

Next tactic:
apply Finset.mem_singleton_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |apply Finset.mem_singleton_self|

Proof state:
case copy
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.copy q✝ ∈ trStmts₁ (Λ'.copy q✝)

Next tactic:
apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · 

Proof state:
case push
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.push k✝ s✝ q✝ ∈ trStmts₁ (Λ'.push k✝ s✝ q✝)

Next tactic:
first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |

Proof state:
case push
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.push k✝ s✝ q✝ ∈ trStmts₁ (Λ'.push k✝ s✝ q✝)

Next tactic:
apply Finset.mem_singleton_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |apply Finset.mem_singleton_self|

Proof state:
case push
k✝ : K'
s✝ : Option Γ' → Option Γ'
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.push k✝ s✝ q✝ ∈ trStmts₁ (Λ'.push k✝ s✝ q✝)

Next tactic:
apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · 

Proof state:
case read
f✝ : Option Γ' → Λ'
f_ih✝ : ∀ (a : Option Γ'), f✝ a ∈ trStmts₁ (f✝ a)
⊢ Λ'.read f✝ ∈ trStmts₁ (Λ'.read f✝)

Next tactic:
first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |

Proof state:
case read
f✝ : Option Γ' → Λ'
f_ih✝ : ∀ (a : Option Γ'), f✝ a ∈ trStmts₁ (f✝ a)
⊢ Λ'.read f✝ ∈ trStmts₁ (Λ'.read f✝)

Next tactic:
apply Finset.mem_singleton_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |apply Finset.mem_singleton_self|

Proof state:
case read
f✝ : Option Γ' → Λ'
f_ih✝ : ∀ (a : Option Γ'), f✝ a ∈ trStmts₁ (f✝ a)
⊢ Λ'.read f✝ ∈ trStmts₁ (Λ'.read f✝)

Next tactic:
apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · 

Proof state:
case succ
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.succ q✝ ∈ trStmts₁ (Λ'.succ q✝)

Next tactic:
first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |

Proof state:
case succ
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.succ q✝ ∈ trStmts₁ (Λ'.succ q✝)

Next tactic:
apply Finset.mem_singleton_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |apply Finset.mem_singleton_self|

Proof state:
case succ
q✝ : Λ'
q_ih✝ : q✝ ∈ trStmts₁ q✝
⊢ Λ'.succ q✝ ∈ trStmts₁ (Λ'.succ q✝)

Next tactic:
apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · 

Proof state:
case pred
q₁✝ q₂✝ : Λ'
q₁_ih✝ : q₁✝ ∈ trStmts₁ q₁✝
q₂_ih✝ : q₂✝ ∈ trStmts₁ q₂✝
⊢ Λ'.pred q₁✝ q₂✝ ∈ trStmts₁ (Λ'.pred q₁✝ q₂✝)

Next tactic:
first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |

Proof state:
case pred
q₁✝ q₂✝ : Λ'
q₁_ih✝ : q₁✝ ∈ trStmts₁ q₁✝
q₂_ih✝ : q₂✝ ∈ trStmts₁ q₂✝
⊢ Λ'.pred q₁✝ q₂✝ ∈ trStmts₁ (Λ'.pred q₁✝ q₂✝)

Next tactic:
apply Finset.mem_singleton_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |apply Finset.mem_singleton_self|

Proof state:
case pred
q₁✝ q₂✝ : Λ'
q₁_ih✝ : q₁✝ ∈ trStmts₁ q₁✝
q₂_ih✝ : q₂✝ ∈ trStmts₁ q₂✝
⊢ Λ'.pred q₁✝ q₂✝ ∈ trStmts₁ (Λ'.pred q₁✝ q₂✝)

Next tactic:
apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · 

Proof state:
case ret
k✝ : Cont'
⊢ Λ'.ret k✝ ∈ trStmts₁ (Λ'.ret k✝)

Next tactic:
first |apply Finset.mem_singleton_self|apply Finset.mem_insert_self
theorem trStmts₁_self (q) : q ∈ trStmts₁ q := by
  induction q <;> · first |

Proof state:
case ret
k✝ : Cont'
⊢ Λ'.ret k✝ ∈ trStmts₁ (Λ'.ret k✝)

Next tactic:
apply Finset.mem_singleton_self