l3lab/ntp-mathlib huggingface dataset:
theorem stmts₁_trans {q₁ q₂ : Stmt₁} : q₁ ∈ stmts₁ q₂ → stmts₁ q₁ ⊆ stmts₁ q₂ := by
  intro h₁₂ q₀ h₀₁
  induction' q₂ with _ q IH _ q IH _ q IH <;> simp only [stmts₁] at h₁₂ ⊢ <;>
    simp only [Finset.mem_insert, Finset.mem_union, Finset.mem_singleton] at h₁₂
  iterate 3
    rcases h₁₂ with (rfl | h₁₂)
    · unfold stmts₁ at h₀₁
      exact h₀₁
    · exact Finset.mem_insert_of_mem (IH h₁₂)
  case branch p q₁ q₂ IH₁ IH₂ =>
    rcases h₁₂ with (rfl | h₁₂ | h₁₂)
    · unfold stmts₁ at h₀₁
      exact h₀₁
    · exact Finset.mem_insert_of_mem (Finset.mem_union_left _ <| IH₁ h₁₂)
    · exact Finset.mem_insert_of_mem (Finset.mem_union_right _ <| IH₂ h₁₂)
  case goto l => subst h₁₂; exact h₀₁
  

Proof state:
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
q₁ q₀ : Stmt₁
h₀₁ : q₀ ∈ stmts₁ q₁
h₁₂ : q₁ = halt
⊢ q₀ ∈ {halt}

Next tactic:
case halt => subst h₁₂; exact h₀₁
theorem stmts₁_trans {q₁ q₂ : Stmt₁} : q₁ ∈ stmts₁ q₂ → stmts₁ q₁ ⊆ stmts₁ q₂ := by
  intro h₁₂ q₀ h₀₁
  induction' q₂ with _ q IH _ q IH _ q IH <;> simp only [stmts₁] at h₁₂ ⊢ <;>
    simp only [Finset.mem_insert, Finset.mem_union, Finset.mem_singleton] at h₁₂
  iterate 3
    rcases h₁₂ with (rfl | h₁₂)
    · unfold stmts₁ at h₀₁
      exact h₀₁
    · exact Finset.mem_insert_of_mem (IH h₁₂)
  case branch p q₁ q₂ IH₁ IH₂ =>
    rcases h₁₂ with (rfl | h₁₂ | h₁₂)
    · unfold stmts₁ at h₀₁
      exact h₀₁
    · exact Finset.mem_insert_of_mem (Finset.mem_union_left _ <| IH₁ h₁₂)
    · exact Finset.mem_insert_of_mem (Finset.mem_union_right _ <| IH₂ h₁₂)
  case goto l => subst h₁₂; exact h₀₁
  case halt => 

Proof state:
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
q₁ q₀ : Stmt₁
h₀₁ : q₀ ∈ stmts₁ q₁
h₁₂ : q₁ = halt
⊢ q₀ ∈ {halt}

Next tactic:
subst h₁₂
theorem stmts₁_trans {q₁ q₂ : Stmt₁} : q₁ ∈ stmts₁ q₂ → stmts₁ q₁ ⊆ stmts₁ q₂ := by
  intro h₁₂ q₀ h₀₁
  induction' q₂ with _ q IH _ q IH _ q IH <;> simp only [stmts₁] at h₁₂ ⊢ <;>
    simp only [Finset.mem_insert, Finset.mem_union, Finset.mem_singleton] at h₁₂
  iterate 3
    rcases h₁₂ with (rfl | h₁₂)
    · unfold stmts₁ at h₀₁
      exact h₀₁
    · exact Finset.mem_insert_of_mem (IH h₁₂)
  case branch p q₁ q₂ IH₁ IH₂ =>
    rcases h₁₂ with (rfl | h₁₂ | h₁₂)
    · unfold stmts₁ at h₀₁
      exact h₀₁
    · exact Finset.mem_insert_of_mem (Finset.mem_union_left _ <| IH₁ h₁₂)
    · exact Finset.mem_insert_of_mem (Finset.mem_union_right _ <| IH₂ h₁₂)
  case goto l => subst h₁₂; exact h₀₁
  case halt => subst h₁₂; 

Proof state:
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
q₀ : Stmt₁
h₀₁ : q₀ ∈ stmts₁ halt
⊢ q₀ ∈ {halt}

Next tactic:
exact h₀₁
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  

Proof state:
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ q₂ : Stmt₁
h : q₁ ∈ stmts₁ q₂
hs : SupportsStmt S q₂
⊢ SupportsStmt S q₁

Next tactic:
induction' q₂ with _ q IH _ q IH _ q IH
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    

Proof state:
case move
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Dir
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
h : q₁ ∈ stmts₁ (move a✝ q)
hs : SupportsStmt S (move a✝ q)
⊢ SupportsStmt S q₁

Next tactic:
simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    

Proof state:
case write
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Γ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
h : q₁ ∈ stmts₁ (write a✝ q)
hs : SupportsStmt S (write a✝ q)
⊢ SupportsStmt S q₁

Next tactic:
simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    

Proof state:
case load
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → σ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
h : q₁ ∈ stmts₁ (load a✝ q)
hs : SupportsStmt S (load a✝ q)
⊢ SupportsStmt S q₁

Next tactic:
simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    

Proof state:
case branch
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝² : Γ → σ → Bool
a✝¹ a✝ : Stmt₁
a_ih✝¹ : q₁ ∈ stmts₁ a✝¹ → SupportsStmt S a✝¹ → SupportsStmt S q₁
a_ih✝ : q₁ ∈ stmts₁ a✝ → SupportsStmt S a✝ → SupportsStmt S q₁
h : q₁ ∈ stmts₁ (branch a✝² a✝¹ a✝)
hs : SupportsStmt S (branch a✝² a✝¹ a✝)
⊢ SupportsStmt S q₁

Next tactic:
simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    

Proof state:
case goto
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Λ
h : q₁ ∈ stmts₁ (goto a✝)
hs : SupportsStmt S (goto a✝)
⊢ SupportsStmt S q₁

Next tactic:
simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    

Proof state:
case halt
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
h : q₁ ∈ stmts₁ halt
hs : SupportsStmt S halt
⊢ SupportsStmt S q₁

Next tactic:
simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  

Proof state:
case move
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Dir
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = move a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁
case write
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Γ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = write a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁
case load
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → σ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = load a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁
case branch
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝² : Γ → σ → Bool
a✝¹ a✝ : Stmt₁
a_ih✝¹ : q₁ ∈ stmts₁ a✝¹ → SupportsStmt S a✝¹ → SupportsStmt S q₁
a_ih✝ : q₁ ∈ stmts₁ a✝ → SupportsStmt S a✝ → SupportsStmt S q₁
hs : SupportsStmt S a✝¹ ∧ SupportsStmt S a✝
h : q₁ = branch a✝² a✝¹ a✝ ∨ q₁ ∈ stmts₁ a✝¹ ∨ q₁ ∈ stmts₁ a✝
⊢ SupportsStmt S q₁
case goto
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Λ
hs : ∀ (a : Γ) (v : σ), a✝ a v ∈ S
h : q₁ = goto a✝
⊢ SupportsStmt S q₁
case halt
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
hs : True
h : q₁ = halt
⊢ SupportsStmt S q₁

Next tactic:
iterate 3 rcases h with (rfl | h) <;> [exact hs; exact IH h hs]
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 

Proof state:
case move
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Dir
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = move a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁
case write
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Γ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = write a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁
case load
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → σ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = load a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁
case branch
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝² : Γ → σ → Bool
a✝¹ a✝ : Stmt₁
a_ih✝¹ : q₁ ∈ stmts₁ a✝¹ → SupportsStmt S a✝¹ → SupportsStmt S q₁
a_ih✝ : q₁ ∈ stmts₁ a✝ → SupportsStmt S a✝ → SupportsStmt S q₁
hs : SupportsStmt S a✝¹ ∧ SupportsStmt S a✝
h : q₁ = branch a✝² a✝¹ a✝ ∨ q₁ ∈ stmts₁ a✝¹ ∨ q₁ ∈ stmts₁ a✝
⊢ SupportsStmt S q₁
case goto
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Λ
hs : ∀ (a : Γ) (v : σ), a✝ a v ∈ S
h : q₁ = goto a✝
⊢ SupportsStmt S q₁
case halt
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
hs : True
h : q₁ = halt
⊢ SupportsStmt S q₁

Next tactic:
rcases h with (rfl | h) <;> [exact hs; exact IH h hs]
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 

Proof state:
case move
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Dir
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = move a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁

Next tactic:
rcases h with (rfl | h)
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [

Proof state:
case move.inl
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
a✝ : Dir
q : Stmt₁
hs : SupportsStmt S q
IH : move a✝ q ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S (move a✝ q)
⊢ SupportsStmt S (move a✝ q)

Next tactic:
exact hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [exact hs; 

Proof state:
case move.inr
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Dir
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁

Next tactic:
exact IH h hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 

Proof state:
case write
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Γ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = write a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁
case load
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → σ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = load a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁
case branch
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝² : Γ → σ → Bool
a✝¹ a✝ : Stmt₁
a_ih✝¹ : q₁ ∈ stmts₁ a✝¹ → SupportsStmt S a✝¹ → SupportsStmt S q₁
a_ih✝ : q₁ ∈ stmts₁ a✝ → SupportsStmt S a✝ → SupportsStmt S q₁
hs : SupportsStmt S a✝¹ ∧ SupportsStmt S a✝
h : q₁ = branch a✝² a✝¹ a✝ ∨ q₁ ∈ stmts₁ a✝¹ ∨ q₁ ∈ stmts₁ a✝
⊢ SupportsStmt S q₁
case goto
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Λ
hs : ∀ (a : Γ) (v : σ), a✝ a v ∈ S
h : q₁ = goto a✝
⊢ SupportsStmt S q₁
case halt
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
hs : True
h : q₁ = halt
⊢ SupportsStmt S q₁

Next tactic:
rcases h with (rfl | h) <;> [exact hs; exact IH h hs]
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 

Proof state:
case write
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Γ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = write a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁

Next tactic:
rcases h with (rfl | h)
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [

Proof state:
case write.inl
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
a✝ : Γ → σ → Γ
q : Stmt₁
hs : SupportsStmt S q
IH : write a✝ q ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S (write a✝ q)
⊢ SupportsStmt S (write a✝ q)

Next tactic:
exact hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [exact hs; 

Proof state:
case write.inr
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Γ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁

Next tactic:
exact IH h hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 

Proof state:
case load
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → σ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = load a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁
case branch
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝² : Γ → σ → Bool
a✝¹ a✝ : Stmt₁
a_ih✝¹ : q₁ ∈ stmts₁ a✝¹ → SupportsStmt S a✝¹ → SupportsStmt S q₁
a_ih✝ : q₁ ∈ stmts₁ a✝ → SupportsStmt S a✝ → SupportsStmt S q₁
hs : SupportsStmt S a✝¹ ∧ SupportsStmt S a✝
h : q₁ = branch a✝² a✝¹ a✝ ∨ q₁ ∈ stmts₁ a✝¹ ∨ q₁ ∈ stmts₁ a✝
⊢ SupportsStmt S q₁
case goto
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Λ
hs : ∀ (a : Γ) (v : σ), a✝ a v ∈ S
h : q₁ = goto a✝
⊢ SupportsStmt S q₁
case halt
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
hs : True
h : q₁ = halt
⊢ SupportsStmt S q₁

Next tactic:
rcases h with (rfl | h) <;> [exact hs; exact IH h hs]
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 

Proof state:
case load
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → σ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ = load a✝ q ∨ q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁

Next tactic:
rcases h with (rfl | h)
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [

Proof state:
case load.inl
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
a✝ : Γ → σ → σ
q : Stmt₁
hs : SupportsStmt S q
IH : load a✝ q ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S (load a✝ q)
⊢ SupportsStmt S (load a✝ q)

Next tactic:
exact hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [exact hs; 

Proof state:
case load.inr
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → σ
q : Stmt₁
IH : q₁ ∈ stmts₁ q → SupportsStmt S q → SupportsStmt S q₁
hs : SupportsStmt S q
h : q₁ ∈ stmts₁ q
⊢ SupportsStmt S q₁

Next tactic:
exact IH h hs
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [exact hs; exact IH h hs]
  

Proof state:
case branch
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝² : Γ → σ → Bool
a✝¹ a✝ : Stmt₁
a_ih✝¹ : q₁ ∈ stmts₁ a✝¹ → SupportsStmt S a✝¹ → SupportsStmt S q₁
a_ih✝ : q₁ ∈ stmts₁ a✝ → SupportsStmt S a✝ → SupportsStmt S q₁
hs : SupportsStmt S a✝¹ ∧ SupportsStmt S a✝
h : q₁ = branch a✝² a✝¹ a✝ ∨ q₁ ∈ stmts₁ a✝¹ ∨ q₁ ∈ stmts₁ a✝
⊢ SupportsStmt S q₁
case goto
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Λ
hs : ∀ (a : Γ) (v : σ), a✝ a v ∈ S
h : q₁ = goto a✝
⊢ SupportsStmt S q₁
case halt
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
hs : True
h : q₁ = halt
⊢ SupportsStmt S q₁

Next tactic:
case branch p q₁ q₂ IH₁ IH₂ => rcases h with (rfl | h | h); exacts [hs, IH₁ h hs.1, IH₂ h hs.2]
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [exact hs; exact IH h hs]
  

Proof state:
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁✝ : Stmt₁
p : Γ → σ → Bool
q₁ q₂ : Stmt₁
IH₁ : q₁✝ ∈ stmts₁ q₁ → SupportsStmt S q₁ → SupportsStmt S q₁✝
IH₂ : q₁✝ ∈ stmts₁ q₂ → SupportsStmt S q₂ → SupportsStmt S q₁✝
hs : SupportsStmt S q₁ ∧ SupportsStmt S q₂
h : q₁✝ = branch p q₁ q₂ ∨ q₁✝ ∈ stmts₁ q₁ ∨ q₁✝ ∈ stmts₁ q₂
⊢ SupportsStmt S q₁✝

Next tactic:
case branch p q₁ q₂ IH₁ IH₂ => rcases h with (rfl | h | h); exacts [hs, IH₁ h hs.1, IH₂ h hs.2]
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [exact hs; exact IH h hs]
  case branch p q₁ q₂ IH₁ IH₂ => 

Proof state:
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁✝ : Stmt₁
p : Γ → σ → Bool
q₁ q₂ : Stmt₁
IH₁ : q₁✝ ∈ stmts₁ q₁ → SupportsStmt S q₁ → SupportsStmt S q₁✝
IH₂ : q₁✝ ∈ stmts₁ q₂ → SupportsStmt S q₂ → SupportsStmt S q₁✝
hs : SupportsStmt S q₁ ∧ SupportsStmt S q₂
h : q₁✝ = branch p q₁ q₂ ∨ q₁✝ ∈ stmts₁ q₁ ∨ q₁✝ ∈ stmts₁ q₂
⊢ SupportsStmt S q₁✝

Next tactic:
rcases h with (rfl | h | h)
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [exact hs; exact IH h hs]
  case branch p q₁ q₂ IH₁ IH₂ => rcases h with (rfl | h | h); 

Proof state:
case inl
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
p : Γ → σ → Bool
q₁ q₂ : Stmt₁
hs : SupportsStmt S q₁ ∧ SupportsStmt S q₂
IH₁ : branch p q₁ q₂ ∈ stmts₁ q₁ → SupportsStmt S q₁ → SupportsStmt S (branch p q₁ q₂)
IH₂ : branch p q₁ q₂ ∈ stmts₁ q₂ → SupportsStmt S q₂ → SupportsStmt S (branch p q₁ q₂)
⊢ SupportsStmt S (branch p q₁ q₂)
case inr.inl
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁✝ : Stmt₁
p : Γ → σ → Bool
q₁ q₂ : Stmt₁
IH₁ : q₁✝ ∈ stmts₁ q₁ → SupportsStmt S q₁ → SupportsStmt S q₁✝
IH₂ : q₁✝ ∈ stmts₁ q₂ → SupportsStmt S q₂ → SupportsStmt S q₁✝
hs : SupportsStmt S q₁ ∧ SupportsStmt S q₂
h : q₁✝ ∈ stmts₁ q₁
⊢ SupportsStmt S q₁✝
case inr.inr
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁✝ : Stmt₁
p : Γ → σ → Bool
q₁ q₂ : Stmt₁
IH₁ : q₁✝ ∈ stmts₁ q₁ → SupportsStmt S q₁ → SupportsStmt S q₁✝
IH₂ : q₁✝ ∈ stmts₁ q₂ → SupportsStmt S q₂ → SupportsStmt S q₁✝
hs : SupportsStmt S q₁ ∧ SupportsStmt S q₂
h : q₁✝ ∈ stmts₁ q₂
⊢ SupportsStmt S q₁✝

Next tactic:
exacts [hs, IH₁ h hs.1, IH₂ h hs.2]
theorem stmts₁_supportsStmt_mono {S : Finset Λ} {q₁ q₂ : Stmt₁} (h : q₁ ∈ stmts₁ q₂)
    (hs : SupportsStmt S q₂) : SupportsStmt S q₁ := by
  induction' q₂ with _ q IH _ q IH _ q IH <;>
    simp only [stmts₁, SupportsStmt, Finset.mem_insert, Finset.mem_union, Finset.mem_singleton]
      at h hs
  iterate 3 rcases h with (rfl | h) <;> [exact hs; exact IH h hs]
  case branch p q₁ q₂ IH₁ IH₂ => rcases h with (rfl | h | h); exacts [hs, IH₁ h hs.1, IH₂ h hs.2]
  

Proof state:
case goto
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
a✝ : Γ → σ → Λ
hs : ∀ (a : Γ) (v : σ), a✝ a v ∈ S
h : q₁ = goto a✝
⊢ SupportsStmt S q₁
case halt
Γ : Type u_1
inst✝ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
S : Finset Λ
q₁ : Stmt₁
hs : True
h : q₁ = halt
⊢ SupportsStmt S q₁

Next tactic:
case goto l => subst h; exact hs