l3lab/ntp-mathlib huggingface dataset:
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    

Proof state:
case Hk
S : Finset Λ'
f fs : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
a_ih✝ : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Λ'.Supports S (trNormal fs k)
k : Cont'
Hk : codeSupp (Code.cons f fs) k ⊆ S
⊢ codeSupp f (Cont'.cons₁ fs k) ⊆ S

Next tactic:
rw [codeSupp_cons] at Hk
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    

Proof state:
case Hk
S : Finset Λ'
f fs : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
a_ih✝ : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Λ'.Supports S (trNormal fs k)
k : Cont'
Hk : trStmts₁ (trNormal (Code.cons f fs) k) ∪ codeSupp f (Cont'.cons₁ fs k) ⊆ S
⊢ codeSupp f (Cont'.cons₁ fs k) ⊆ S

Next tactic:
exact Finset.union_subset_right Hk
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  

Proof state:
case comp
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k)
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k)
k : Cont'
Hk : codeSupp (Code.comp a✝¹ a✝) k ⊆ S
⊢ Λ'.Supports S (trNormal a✝ (Cont'.comp a✝¹ k))
case case
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k)
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k)
k : Cont'
Hk : codeSupp (Code.case a✝¹ a✝) k ⊆ S
⊢ Λ'.Supports S (trNormal a✝¹ k) ∧ Λ'.Supports S (trNormal a✝ k)
case fix
S : Finset Λ'
a✝ : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k)
k : Cont'
Hk : codeSupp (Code.fix a✝) k ⊆ S
⊢ Λ'.Supports S (trNormal a✝ (Cont'.fix a✝ k))

Next tactic:
case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  

Proof state:
S : Finset Λ'
f g : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k)
k : Cont'
Hk : codeSupp (Code.comp f g) k ⊆ S
⊢ Λ'.Supports S (trNormal g (Cont'.comp f k))

Next tactic:
case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => 

Proof state:
S : Finset Λ'
f g : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k)
k : Cont'
Hk : codeSupp (Code.comp f g) k ⊆ S
⊢ Λ'.Supports S (trNormal g (Cont'.comp f k))

Next tactic:
apply IHg
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; 

Proof state:
case Hk
S : Finset Λ'
f g : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k)
k : Cont'
Hk : codeSupp (Code.comp f g) k ⊆ S
⊢ codeSupp g (Cont'.comp f k) ⊆ S

Next tactic:
rw [codeSupp_comp] at Hk
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; 

Proof state:
case Hk
S : Finset Λ'
f g : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k)
k : Cont'
Hk : trStmts₁ (trNormal (Code.comp f g) k) ∪ codeSupp g (Cont'.comp f k) ⊆ S
⊢ codeSupp g (Cont'.comp f k) ⊆ S

Next tactic:
exact Finset.union_subset_right Hk
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
  

Proof state:
case case
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Λ'.Supports S (trNormal a✝¹ k)
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k)
k : Cont'
Hk : codeSupp (Code.case a✝¹ a✝) k ⊆ S
⊢ Λ'.Supports S (trNormal a✝¹ k) ∧ Λ'.Supports S (trNormal a✝ k)
case fix
S : Finset Λ'
a✝ : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k)
k : Cont'
Hk : codeSupp (Code.fix a✝) k ⊆ S
⊢ Λ'.Supports S (trNormal a✝ (Cont'.fix a✝ k))

Next tactic:
case
    case f g IHf IHg =>
    simp only [codeSupp_case, Finset.union_subset_iff] at Hk
    exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
  

Proof state:
S : Finset Λ'
f g : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k)
k : Cont'
Hk : codeSupp (Code.case f g) k ⊆ S
⊢ Λ'.Supports S (trNormal f k) ∧ Λ'.Supports S (trNormal g k)

Next tactic:
case
    case f g IHf IHg =>
    simp only [codeSupp_case, Finset.union_subset_iff] at Hk
    exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
  case
    case f g IHf IHg =>
    

Proof state:
S : Finset Λ'
f g : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k)
k : Cont'
Hk : codeSupp (Code.case f g) k ⊆ S
⊢ Λ'.Supports S (trNormal f k) ∧ Λ'.Supports S (trNormal g k)

Next tactic:
simp only [codeSupp_case, Finset.union_subset_iff] at Hk
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
  case
    case f g IHf IHg =>
    simp only [codeSupp_case, Finset.union_subset_iff] at Hk
    

Proof state:
S : Finset Λ'
f g : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
IHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Λ'.Supports S (trNormal g k)
k : Cont'
Hk : trStmts₁ (trNormal (Code.case f g) k) ⊆ S ∧ codeSupp f k ⊆ S ∧ codeSupp g k ⊆ S
⊢ Λ'.Supports S (trNormal f k) ∧ Λ'.Supports S (trNormal g k)

Next tactic:
exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
  case
    case f g IHf IHg =>
    simp only [codeSupp_case, Finset.union_subset_iff] at Hk
    exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩
  

Proof state:
case fix
S : Finset Λ'
a✝ : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Λ'.Supports S (trNormal a✝ k)
k : Cont'
Hk : codeSupp (Code.fix a✝) k ⊆ S
⊢ Λ'.Supports S (trNormal a✝ (Cont'.fix a✝ k))

Next tactic:
case fix f IHf => apply IHf; rw [codeSupp_fix] at Hk; exact Finset.union_subset_right Hk
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
  case
    case f g IHf IHg =>
    simp only [codeSupp_case, Finset.union_subset_iff] at Hk
    exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩
  

Proof state:
S : Finset Λ'
f : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
k : Cont'
Hk : codeSupp (Code.fix f) k ⊆ S
⊢ Λ'.Supports S (trNormal f (Cont'.fix f k))

Next tactic:
case fix f IHf => apply IHf; rw [codeSupp_fix] at Hk; exact Finset.union_subset_right Hk
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
  case
    case f g IHf IHg =>
    simp only [codeSupp_case, Finset.union_subset_iff] at Hk
    exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩
  case fix f IHf => 

Proof state:
S : Finset Λ'
f : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
k : Cont'
Hk : codeSupp (Code.fix f) k ⊆ S
⊢ Λ'.Supports S (trNormal f (Cont'.fix f k))

Next tactic:
apply IHf
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
  case
    case f g IHf IHg =>
    simp only [codeSupp_case, Finset.union_subset_iff] at Hk
    exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩
  case fix f IHf => apply IHf; 

Proof state:
case Hk
S : Finset Λ'
f : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
k : Cont'
Hk : codeSupp (Code.fix f) k ⊆ S
⊢ codeSupp f (Cont'.fix f k) ⊆ S

Next tactic:
rw [codeSupp_fix] at Hk
theorem trNormal_supports {S c k} (Hk : codeSupp c k ⊆ S) : (trNormal c k).Supports S := by
  induction c generalizing k <;> simp [Λ'.Supports, head]
  case zero' => exact Finset.union_subset_right Hk
  case succ => intro; split_ifs <;> exact Finset.union_subset_right Hk
  case tail => exact Finset.union_subset_right Hk
  case cons f fs IHf _ =>
    apply IHf
    rw [codeSupp_cons] at Hk
    exact Finset.union_subset_right Hk
  case comp f g _ IHg => apply IHg; rw [codeSupp_comp] at Hk; exact Finset.union_subset_right Hk
  case
    case f g IHf IHg =>
    simp only [codeSupp_case, Finset.union_subset_iff] at Hk
    exact ⟨IHf Hk.2.1, IHg Hk.2.2⟩
  case fix f IHf => apply IHf; rw [codeSupp_fix] at Hk; 

Proof state:
case Hk
S : Finset Λ'
f : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Λ'.Supports S (trNormal f k)
k : Cont'
Hk : trStmts₁ (trNormal (Code.fix f) k) ∪ codeSupp f (Cont'.fix f k) ⊆ S
⊢ codeSupp f (Cont'.fix f k) ⊆ S

Next tactic:
exact Finset.union_subset_right Hk
theorem codeSupp'_supports {S c k} (H : codeSupp c k ⊆ S) : Supports (codeSupp' c k) S := by
  

Proof state:
S : Finset Λ'
c : Code
k : Cont'
H : codeSupp c k ⊆ S
⊢ Supports (codeSupp' c k) S

Next tactic:
induction c generalizing k
theorem codeSupp'_supports {S c k} (H : codeSupp c k ⊆ S) : Supports (codeSupp' c k) S := by
  induction c generalizing k
  

Proof state:
case zero'
S : Finset Λ'
k : Cont'
H : codeSupp Code.zero' k ⊆ S
⊢ Supports (codeSupp' Code.zero' k) S
case succ
S : Finset Λ'
k : Cont'
H : codeSupp Code.succ k ⊆ S
⊢ Supports (codeSupp' Code.succ k) S
case tail
S : Finset Λ'
k : Cont'
H : codeSupp Code.tail k ⊆ S
⊢ Supports (codeSupp' Code.tail k) S
case cons
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.cons a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.cons a✝¹ a✝) k) S
case comp
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.comp a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.comp a✝¹ a✝) k) S
case case
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.case a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.case a✝¹ a✝) k) S
case fix
S : Finset Λ'
a✝ : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.fix a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.fix a✝) k) S

Next tactic:
iterate 3
    exact trStmts₁_supports (trNormal_supports H) (Finset.Subset.trans (codeSupp_self _ _) H)
theorem codeSupp'_supports {S c k} (H : codeSupp c k ⊆ S) : Supports (codeSupp' c k) S := by
  induction c generalizing k
  iterate 3
    

Proof state:
case zero'
S : Finset Λ'
k : Cont'
H : codeSupp Code.zero' k ⊆ S
⊢ Supports (codeSupp' Code.zero' k) S
case succ
S : Finset Λ'
k : Cont'
H : codeSupp Code.succ k ⊆ S
⊢ Supports (codeSupp' Code.succ k) S
case tail
S : Finset Λ'
k : Cont'
H : codeSupp Code.tail k ⊆ S
⊢ Supports (codeSupp' Code.tail k) S
case cons
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.cons a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.cons a✝¹ a✝) k) S
case comp
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.comp a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.comp a✝¹ a✝) k) S
case case
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.case a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.case a✝¹ a✝) k) S
case fix
S : Finset Λ'
a✝ : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.fix a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.fix a✝) k) S

Next tactic:
exact trStmts₁_supports (trNormal_supports H) (Finset.Subset.trans (codeSupp_self _ _) H)
theorem codeSupp'_supports {S c k} (H : codeSupp c k ⊆ S) : Supports (codeSupp' c k) S := by
  induction c generalizing k
  iterate 3
    

Proof state:
case succ
S : Finset Λ'
k : Cont'
H : codeSupp Code.succ k ⊆ S
⊢ Supports (codeSupp' Code.succ k) S
case tail
S : Finset Λ'
k : Cont'
H : codeSupp Code.tail k ⊆ S
⊢ Supports (codeSupp' Code.tail k) S
case cons
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.cons a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.cons a✝¹ a✝) k) S
case comp
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.comp a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.comp a✝¹ a✝) k) S
case case
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.case a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.case a✝¹ a✝) k) S
case fix
S : Finset Λ'
a✝ : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.fix a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.fix a✝) k) S

Next tactic:
exact trStmts₁_supports (trNormal_supports H) (Finset.Subset.trans (codeSupp_self _ _) H)
theorem codeSupp'_supports {S c k} (H : codeSupp c k ⊆ S) : Supports (codeSupp' c k) S := by
  induction c generalizing k
  iterate 3
    

Proof state:
case tail
S : Finset Λ'
k : Cont'
H : codeSupp Code.tail k ⊆ S
⊢ Supports (codeSupp' Code.tail k) S
case cons
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.cons a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.cons a✝¹ a✝) k) S
case comp
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.comp a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.comp a✝¹ a✝) k) S
case case
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.case a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.case a✝¹ a✝) k) S
case fix
S : Finset Λ'
a✝ : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.fix a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.fix a✝) k) S

Next tactic:
exact trStmts₁_supports (trNormal_supports H) (Finset.Subset.trans (codeSupp_self _ _) H)
theorem codeSupp'_supports {S c k} (H : codeSupp c k ⊆ S) : Supports (codeSupp' c k) S := by
  induction c generalizing k
  iterate 3
    exact trStmts₁_supports (trNormal_supports H) (Finset.Subset.trans (codeSupp_self _ _) H)
  

Proof state:
case cons
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.cons a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.cons a✝¹ a✝) k) S
case comp
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.comp a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.comp a✝¹ a✝) k) S
case case
S : Finset Λ'
a✝¹ a✝ : Code
a_ih✝¹ : ∀ {k : Cont'}, codeSupp a✝¹ k ⊆ S → Supports (codeSupp' a✝¹ k) S
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.case a✝¹ a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.case a✝¹ a✝) k) S
case fix
S : Finset Λ'
a✝ : Code
a_ih✝ : ∀ {k : Cont'}, codeSupp a✝ k ⊆ S → Supports (codeSupp' a✝ k) S
k : Cont'
H : codeSupp (Code.fix a✝) k ⊆ S
⊢ Supports (codeSupp' (Code.fix a✝) k) S

Next tactic:
case cons f fs IHf IHfs =>
    have H' := H; simp only [codeSupp_cons, Finset.union_subset_iff] at H'
    refine' trStmts₁_supports' (trNormal_supports H) (Finset.union_subset_left H) fun h => _
    refine' supports_union.2 ⟨IHf H'.2, _⟩
    refine' trStmts₁_supports' (trNormal_supports _) (Finset.union_subset_right h) fun h => _
    · simp only [codeSupp, Finset.union_subset_iff, contSupp] at h H ⊢
      exact ⟨h.2.2.1, h.2.2.2, H.2⟩
    refine' supports_union.2 ⟨IHfs _, _⟩
    · rw [codeSupp, contSupp_cons₁] at H'
      exact Finset.union_subset_right (Finset.union_subset_right H'.2)
    exact
      trStmts₁_supports (head_supports <| Finset.union_subset_right H)
        (Finset.union_subset_right h)
theorem codeSupp'_supports {S c k} (H : codeSupp c k ⊆ S) : Supports (codeSupp' c k) S := by
  induction c generalizing k
  iterate 3
    exact trStmts₁_supports (trNormal_supports H) (Finset.Subset.trans (codeSupp_self _ _) H)
  

Proof state:
S : Finset Λ'
f fs : Code
IHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S
IHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S
k : Cont'
H : codeSupp (Code.cons f fs) k ⊆ S
⊢ Supports (codeSupp' (Code.cons f fs) k) S

Next tactic:
case cons f fs IHf IHfs =>
    have H' := H; simp only [codeSupp_cons, Finset.union_subset_iff] at H'
    refine' trStmts₁_supports' (trNormal_supports H) (Finset.union_subset_left H) fun h => _
    refine' supports_union.2 ⟨IHf H'.2, _⟩
    refine' trStmts₁_supports' (trNormal_supports _) (Finset.union_subset_right h) fun h => _
    · simp only [codeSupp, Finset.union_subset_iff, contSupp] at h H ⊢
      exact ⟨h.2.2.1, h.2.2.2, H.2⟩
    refine' supports_union.2 ⟨IHfs _, _⟩
    · rw [codeSupp, contSupp_cons₁] at H'
      exact Finset.union_subset_right (Finset.union_subset_right H'.2)
    exact
      trStmts₁_supports (head_supports <| Finset.union_subset_right H)
        (Finset.union_subset_right h)