l3lab/ntp-mathlib huggingface dataset:
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; 

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H H₁ : contSupp (Cont'.cons₁ f k) ⊆ S
⊢ Supports (contSupp (Cont'.cons₁ f k)) S

Next tactic:
rw [contSupp_cons₁] at H₁
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; 

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.cons₁ f k) ⊆ S
H₁ :
  trStmts₁
        (move₂ (fun x => false) main aux
          (move₂ (fun s => decide (s = Γ'.consₗ)) stack main
            (move₂ (fun x => false) aux stack (trNormal f (Cont'.cons₂ k))))) ∪
      codeSupp f (Cont'.cons₂ k) ⊆
    S
⊢ Supports (contSupp (Cont'.cons₁ f k)) S

Next tactic:
have H₂ := Finset.union_subset_right H₁
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.cons₁ f k) ⊆ S
H₁ :
  trStmts₁
        (move₂ (fun x => false) main aux
          (move₂ (fun s => decide (s = Γ'.consₗ)) stack main
            (move₂ (fun x => false) aux stack (trNormal f (Cont'.cons₂ k))))) ∪
      codeSupp f (Cont'.cons₂ k) ⊆
    S
H₂ : codeSupp f (Cont'.cons₂ k) ⊆ S
⊢ Supports (contSupp (Cont'.cons₁ f k)) S

Next tactic:
refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.cons₁ f k) ⊆ S
H₁ :
  trStmts₁
        (move₂ (fun x => false) main aux
          (move₂ (fun s => decide (s = Γ'.consₗ)) stack main
            (move₂ (fun x => false) aux stack (trNormal f (Cont'.cons₂ k))))) ∪
      codeSupp f (Cont'.cons₂ k) ⊆
    S
H₂ : codeSupp f (Cont'.cons₂ k) ⊆ S
h : codeSupp' f (Cont'.cons₂ k) ∪ (trStmts₁ (head stack (Λ'.ret k)) ∪ contSupp k) ⊆ S
⊢ Supports (codeSupp' f (Cont'.cons₂ k) ∪ (trStmts₁ (head stack (Λ'.ret k)) ∪ contSupp k)) S

Next tactic:
refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.cons₁ f k) ⊆ S
H₁ :
  trStmts₁
        (move₂ (fun x => false) main aux
          (move₂ (fun s => decide (s = Γ'.consₗ)) stack main
            (move₂ (fun x => false) aux stack (trNormal f (Cont'.cons₂ k))))) ∪
      codeSupp f (Cont'.cons₂ k) ⊆
    S
H₂ : codeSupp f (Cont'.cons₂ k) ⊆ S
h : codeSupp' f (Cont'.cons₂ k) ∪ (trStmts₁ (head stack (Λ'.ret k)) ∪ contSupp k) ⊆ S
⊢ Supports (trStmts₁ (head stack (Λ'.ret k)) ∪ contSupp k) S

Next tactic:
simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.cons₁ f k) ⊆ S
H₁ :
  trStmts₁
        (move₂ (fun x => false) main aux
          (move₂ (fun s => decide (s = Γ'.consₗ)) stack main
            (move₂ (fun x => false) aux stack (trNormal f (Cont'.cons₂ k))))) ∪
      codeSupp f (Cont'.cons₂ k) ⊆
    S
h : codeSupp' f (Cont'.cons₂ k) ∪ (trStmts₁ (head stack (Λ'.ret k)) ∪ contSupp k) ⊆ S
H₂ : codeSupp' f (Cont'.cons₂ k) ⊆ S ∧ trStmts₁ (head stack (Λ'.ret k)) ⊆ S ∧ contSupp k ⊆ S
⊢ Supports (trStmts₁ (head stack (Λ'.ret k)) ∪ contSupp k) S

Next tactic:
exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  

Proof state:
case cons₂
S : Finset Λ'
a✝ : Cont'
a_ih✝ : contSupp a✝ ⊆ S → Supports (contSupp a✝) S
H : contSupp (Cont'.cons₂ a✝) ⊆ S
⊢ Supports (contSupp (Cont'.cons₂ a✝)) S
case comp
S : Finset Λ'
a✝¹ : Code
a✝ : Cont'
a_ih✝ : contSupp a✝ ⊆ S → Supports (contSupp a✝) S
H : contSupp (Cont'.comp a✝¹ a✝) ⊆ S
⊢ Supports (contSupp (Cont'.comp a✝¹ a✝)) S
case fix
S : Finset Λ'
a✝¹ : Code
a✝ : Cont'
a_ih✝ : contSupp a✝ ⊆ S → Supports (contSupp a✝) S
H : contSupp (Cont'.fix a✝¹ a✝) ⊆ S
⊢ Supports (contSupp (Cont'.fix a✝¹ a✝)) S

Next tactic:
case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  

Proof state:
S : Finset Λ'
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.cons₂ k) ⊆ S
⊢ Supports (contSupp (Cont'.cons₂ k)) S

Next tactic:
case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    

Proof state:
S : Finset Λ'
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.cons₂ k) ⊆ S
⊢ Supports (contSupp (Cont'.cons₂ k)) S

Next tactic:
have H' := H
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; 

Proof state:
S : Finset Λ'
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H H' : contSupp (Cont'.cons₂ k) ⊆ S
⊢ Supports (contSupp (Cont'.cons₂ k)) S

Next tactic:
rw [contSupp_cons₂] at H'
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    

Proof state:
S : Finset Λ'
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.cons₂ k) ⊆ S
H' : trStmts₁ (head stack (Λ'.ret k)) ∪ contSupp k ⊆ S
⊢ Supports (contSupp (Cont'.cons₂ k)) S

Next tactic:
exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
  

Proof state:
case comp
S : Finset Λ'
a✝¹ : Code
a✝ : Cont'
a_ih✝ : contSupp a✝ ⊆ S → Supports (contSupp a✝) S
H : contSupp (Cont'.comp a✝¹ a✝) ⊆ S
⊢ Supports (contSupp (Cont'.comp a✝¹ a✝)) S
case fix
S : Finset Λ'
a✝¹ : Code
a✝ : Cont'
a_ih✝ : contSupp a✝ ⊆ S → Supports (contSupp a✝) S
H : contSupp (Cont'.fix a✝¹ a✝) ⊆ S
⊢ Supports (contSupp (Cont'.fix a✝¹ a✝)) S

Next tactic:
case comp f k IH =>
    have H' := H; rw [contSupp_comp] at H'; have H₂ := Finset.union_subset_right H'
    exact supports_union.2 ⟨codeSupp'_supports H', IH H₂⟩
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
  

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.comp f k) ⊆ S
⊢ Supports (contSupp (Cont'.comp f k)) S

Next tactic:
case comp f k IH =>
    have H' := H; rw [contSupp_comp] at H'; have H₂ := Finset.union_subset_right H'
    exact supports_union.2 ⟨codeSupp'_supports H', IH H₂⟩
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
  case comp f k IH =>
    

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.comp f k) ⊆ S
⊢ Supports (contSupp (Cont'.comp f k)) S

Next tactic:
have H' := H
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
  case comp f k IH =>
    have H' := H; 

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H H' : contSupp (Cont'.comp f k) ⊆ S
⊢ Supports (contSupp (Cont'.comp f k)) S

Next tactic:
rw [contSupp_comp] at H'
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
  case comp f k IH =>
    have H' := H; rw [contSupp_comp] at H'; 

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.comp f k) ⊆ S
H' : codeSupp f k ⊆ S
⊢ Supports (contSupp (Cont'.comp f k)) S

Next tactic:
have H₂ := Finset.union_subset_right H'
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
  case comp f k IH =>
    have H' := H; rw [contSupp_comp] at H'; have H₂ := Finset.union_subset_right H'
    

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.comp f k) ⊆ S
H' : codeSupp f k ⊆ S
H₂ : contSupp k ⊆ S
⊢ Supports (contSupp (Cont'.comp f k)) S

Next tactic:
exact supports_union.2 ⟨codeSupp'_supports H', IH H₂⟩
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
  case comp f k IH =>
    have H' := H; rw [contSupp_comp] at H'; have H₂ := Finset.union_subset_right H'
    exact supports_union.2 ⟨codeSupp'_supports H', IH H₂⟩
  

Proof state:
case fix
S : Finset Λ'
a✝¹ : Code
a✝ : Cont'
a_ih✝ : contSupp a✝ ⊆ S → Supports (contSupp a✝) S
H : contSupp (Cont'.fix a✝¹ a✝) ⊆ S
⊢ Supports (contSupp (Cont'.fix a✝¹ a✝)) S

Next tactic:
case fix f k IH =>
    rw [contSupp] at H
    exact supports_union.2 ⟨codeSupp'_supports H, IH (Finset.union_subset_right H)⟩
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
  case comp f k IH =>
    have H' := H; rw [contSupp_comp] at H'; have H₂ := Finset.union_subset_right H'
    exact supports_union.2 ⟨codeSupp'_supports H', IH H₂⟩
  

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.fix f k) ⊆ S
⊢ Supports (contSupp (Cont'.fix f k)) S

Next tactic:
case fix f k IH =>
    rw [contSupp] at H
    exact supports_union.2 ⟨codeSupp'_supports H, IH (Finset.union_subset_right H)⟩
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
  case comp f k IH =>
    have H' := H; rw [contSupp_comp] at H'; have H₂ := Finset.union_subset_right H'
    exact supports_union.2 ⟨codeSupp'_supports H', IH H₂⟩
  case fix f k IH =>
    

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : contSupp (Cont'.fix f k) ⊆ S
⊢ Supports (contSupp (Cont'.fix f k)) S

Next tactic:
rw [contSupp] at H
theorem contSupp_supports {S k} (H : contSupp k ⊆ S) : Supports (contSupp k) S := by
  induction k
  · simp [contSupp_halt, Supports]
  case cons₁ f k IH =>
    have H₁ := H; rw [contSupp_cons₁] at H₁; have H₂ := Finset.union_subset_right H₁
    refine' trStmts₁_supports' (trNormal_supports H₂) H₁ fun h => _
    refine' supports_union.2 ⟨codeSupp'_supports H₂, _⟩
    simp only [codeSupp, contSupp_cons₂, Finset.union_subset_iff] at H₂
    exact trStmts₁_supports' (head_supports H₂.2.2) (Finset.union_subset_right h) IH
  case cons₂ k IH =>
    have H' := H; rw [contSupp_cons₂] at H'
    exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH
  case comp f k IH =>
    have H' := H; rw [contSupp_comp] at H'; have H₂ := Finset.union_subset_right H'
    exact supports_union.2 ⟨codeSupp'_supports H', IH H₂⟩
  case fix f k IH =>
    rw [contSupp] at H
    

Proof state:
S : Finset Λ'
f : Code
k : Cont'
IH : contSupp k ⊆ S → Supports (contSupp k) S
H : codeSupp' (Code.fix f) k ∪ contSupp k ⊆ S
⊢ Supports (contSupp (Cont'.fix f k)) S

Next tactic:
exact supports_union.2 ⟨codeSupp'_supports H, IH (Finset.union_subset_right H)⟩
/-- We prove that if every subring of `D` is central, then so is `D`. -/
private theorem center_eq_top [Finite D] (hD : InductionHyp D) : Subring.center D = ⊤ := by
  classical
  

Proof state:
D : Type u_1
inst✝¹ : DivisionRing D
inst✝ : Finite D
hD : LittleWedderburn.InductionHyp D
⊢ Subring.center D = ⊤

Next tactic:
cases nonempty_fintype D
/-- We prove that if every subring of `D` is central, then so is `D`. -/
private theorem center_eq_top [Finite D] (hD : InductionHyp D) : Subring.center D = ⊤ := by
  classical
  cases nonempty_fintype D
  

Proof state:
case intro
D : Type u_1
inst✝¹ : DivisionRing D
inst✝ : Finite D
hD : LittleWedderburn.InductionHyp D
val✝ : Fintype D
⊢ Subring.center D = ⊤

Next tactic:
set Z := Subring.center D
/-- We prove that if every subring of `D` is central, then so is `D`. -/
private theorem center_eq_top [Finite D] (hD : InductionHyp D) : Subring.center D = ⊤ := by
  classical
  cases nonempty_fintype D
  set Z := Subring.center D
  -- We proceed by contradiction; that is, we assume the center is strictly smaller than `D`.
  

Proof state:
case intro
D : Type u_1
inst✝¹ : DivisionRing D
inst✝ : Finite D
hD : LittleWedderburn.InductionHyp D
val✝ : Fintype D
Z : Subring D := Subring.center D
⊢ Z = ⊤

Next tactic:
by_contra! hZ
/-- We prove that if every subring of `D` is central, then so is `D`. -/
private theorem center_eq_top [Finite D] (hD : InductionHyp D) : Subring.center D = ⊤ := by
  classical
  cases nonempty_fintype D
  set Z := Subring.center D
  -- We proceed by contradiction; that is, we assume the center is strictly smaller than `D`.
  by_contra! hZ
  

Proof state:
case intro
D : Type u_1
inst✝¹ : DivisionRing D
inst✝ : Finite D
hD : LittleWedderburn.InductionHyp D
val✝ : Fintype D
Z : Subring D := Subring.center D
hZ : Z ≠ ⊤
⊢ False

Next tactic:
letI : Field Z := hD.field hZ.lt_top
/-- We prove that if every subring of `D` is central, then so is `D`. -/
private theorem center_eq_top [Finite D] (hD : InductionHyp D) : Subring.center D = ⊤ := by
  classical
  cases nonempty_fintype D
  set Z := Subring.center D
  -- We proceed by contradiction; that is, we assume the center is strictly smaller than `D`.
  by_contra! hZ
  letI : Field Z := hD.field hZ.lt_top
  

Proof state:
case intro
D : Type u_1
inst✝¹ : DivisionRing D
inst✝ : Finite D
hD : LittleWedderburn.InductionHyp D
val✝ : Fintype D
Z : Subring D := Subring.center D
hZ : Z ≠ ⊤
this : Field ↥Z := LittleWedderburn.InductionHyp.field hD (_ : Z < ⊤)
⊢ False

Next tactic:
set q := card Z with card_Z
/-- We prove that if every subring of `D` is central, then so is `D`. -/
private theorem center_eq_top [Finite D] (hD : InductionHyp D) : Subring.center D = ⊤ := by
  classical
  cases nonempty_fintype D
  set Z := Subring.center D
  -- We proceed by contradiction; that is, we assume the center is strictly smaller than `D`.
  by_contra! hZ
  letI : Field Z := hD.field hZ.lt_top
  set q := card Z with card_Z
  

Proof state:
case intro
D : Type u_1
inst✝¹ : DivisionRing D
inst✝ : Finite D
hD : LittleWedderburn.InductionHyp D
val✝ : Fintype D
Z : Subring D := Subring.center D
hZ : Z ≠ ⊤
this : Field ↥Z := LittleWedderburn.InductionHyp.field hD (_ : Z < ⊤)
q : ℕ := card ↥Z
card_Z : q = card ↥Z
⊢ False

Next tactic:
have hq : 1 < q := by rw [card_Z]; exact one_lt_card
/-- We prove that if every subring of `D` is central, then so is `D`. -/
private theorem center_eq_top [Finite D] (hD : InductionHyp D) : Subring.center D = ⊤ := by
  classical
  cases nonempty_fintype D
  set Z := Subring.center D
  -- We proceed by contradiction; that is, we assume the center is strictly smaller than `D`.
  by_contra! hZ
  letI : Field Z := hD.field hZ.lt_top
  set q := card Z with card_Z
  have hq : 1 < q := by 

Proof state:
D : Type u_1
inst✝¹ : DivisionRing D
inst✝ : Finite D
hD : LittleWedderburn.InductionHyp D
val✝ : Fintype D
Z : Subring D := Subring.center D
hZ : Z ≠ ⊤
this : Field ↥Z := LittleWedderburn.InductionHyp.field hD (_ : Z < ⊤)
q : ℕ := card ↥Z
card_Z : q = card ↥Z
⊢ 1 < q

Next tactic:
rw [card_Z]