l3lab/ntp-mathlib huggingface dataset:
theorem sup'_product_left {t : Finset γ} (hs : s.Nonempty) (ht : t.Nonempty) (f : β × γ → α) :
    (s ×ˢ t).sup' (hs.product ht) f = s.sup' hs fun i => t.sup' ht fun i' => f ⟨i, i'⟩ :=
  eq_of_forall_ge_iff fun a => by 

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f✝ : β → α
t : Finset γ
hs : Finset.Nonempty s
ht : Finset.Nonempty t
f : β × γ → α
a : α
⊢ sup' (s ×ˢ t) (_ : Finset.Nonempty (s ×ˢ t)) f ≤ a ↔ (sup' s hs fun i => sup' t ht fun i' => f (i, i')) ≤ a

Next tactic:
simp [@forall_swap _ γ]
theorem sup'_product_right {t : Finset γ} (hs : s.Nonempty) (ht : t.Nonempty) (f : β × γ → α) :
    (s ×ˢ t).sup' (hs.product ht) f = t.sup' ht fun i' => s.sup' hs fun i => f ⟨i, i'⟩ := by
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f✝ : β → α
t : Finset γ
hs : Finset.Nonempty s
ht : Finset.Nonempty t
f : β × γ → α
⊢ sup' (s ×ˢ t) (_ : Finset.Nonempty (s ×ˢ t)) f = sup' t ht fun i' => sup' s hs fun i => f (i, i')

Next tactic:
rw [sup'_product_left, Finset.sup'_comm]
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
⊢ g (sup' s H f) = sup' s H (g ∘ f)

Next tactic:
rw [← WithBot.coe_eq_coe, coe_sup']
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
⊢ ↑(g (sup' s H f)) = sup s (WithBot.some ∘ g ∘ f)

Next tactic:
let g' := WithBot.map g
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
⊢ ↑(g (sup' s H f)) = sup s (WithBot.some ∘ g ∘ f)

Next tactic:
show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
⊢ g' ↑(sup' s H f) = sup s fun a => g' ↑(f a)

Next tactic:
rw [coe_sup']
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
⊢ g' (sup s (WithBot.some ∘ f)) = sup s fun a => g' ↑(f a)

Next tactic:
refine' comp_sup_eq_sup_comp g' _ rfl
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
⊢ ∀ (x y : WithBot α), g' (x ⊔ y) = g' x ⊔ g' y

Next tactic:
intro f₁ f₂
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  intro f₁ f₂
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
f₁ f₂ : WithBot α
⊢ g' (f₁ ⊔ f₂) = g' f₁ ⊔ g' f₂

Next tactic:
cases f₁ using WithBot.recBotCoe with
  | bot =>
    rw [bot_sup_eq]
    exact bot_sup_eq.symm
  | coe f₁ =>
    cases f₂ using WithBot.recBotCoe with
    | bot => rfl
    | coe f₂ => exact congr_arg _ (g_sup f₁ f₂)
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  intro f₁ f₂
  cases f₁ using WithBot.recBotCoe with
  

Proof state:
case bot
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
f₂ : WithBot α
⊢ g' (⊥ ⊔ f₂) = g' ⊥ ⊔ g' f₂

Next tactic:
| bot =>
    rw [bot_sup_eq]
    exact bot_sup_eq.symm
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  intro f₁ f₂
  cases f₁ using WithBot.recBotCoe with
  | bot =>
    

Proof state:
case bot
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
f₂ : WithBot α
⊢ g' (⊥ ⊔ f₂) = g' ⊥ ⊔ g' f₂

Next tactic:
rw [bot_sup_eq]
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  intro f₁ f₂
  cases f₁ using WithBot.recBotCoe with
  | bot =>
    rw [bot_sup_eq]
    

Proof state:
case bot
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
f₂ : WithBot α
⊢ g' f₂ = g' ⊥ ⊔ g' f₂

Next tactic:
exact bot_sup_eq.symm
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  intro f₁ f₂
  cases f₁ using WithBot.recBotCoe with
  | bot =>
    rw [bot_sup_eq]
    exact bot_sup_eq.symm
  

Proof state:
case coe
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
f₂ : WithBot α
f₁ : α
⊢ g' (↑f₁ ⊔ f₂) = g' ↑f₁ ⊔ g' f₂

Next tactic:
| coe f₁ =>
    cases f₂ using WithBot.recBotCoe with
    | bot => rfl
    | coe f₂ => exact congr_arg _ (g_sup f₁ f₂)
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  intro f₁ f₂
  cases f₁ using WithBot.recBotCoe with
  | bot =>
    rw [bot_sup_eq]
    exact bot_sup_eq.symm
  | coe f₁ =>
    

Proof state:
case coe
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
f₂ : WithBot α
f₁ : α
⊢ g' (↑f₁ ⊔ f₂) = g' ↑f₁ ⊔ g' f₂

Next tactic:
cases f₂ using WithBot.recBotCoe with
    | bot => rfl
    | coe f₂ => exact congr_arg _ (g_sup f₁ f₂)
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  intro f₁ f₂
  cases f₁ using WithBot.recBotCoe with
  | bot =>
    rw [bot_sup_eq]
    exact bot_sup_eq.symm
  | coe f₁ =>
    cases f₂ using WithBot.recBotCoe with
    

Proof state:
case coe.bot
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
f₁ : α
⊢ g' (↑f₁ ⊔ ⊥) = g' ↑f₁ ⊔ g' ⊥

Next tactic:
| bot => rfl
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  intro f₁ f₂
  cases f₁ using WithBot.recBotCoe with
  | bot =>
    rw [bot_sup_eq]
    exact bot_sup_eq.symm
  | coe f₁ =>
    cases f₂ using WithBot.recBotCoe with
    | bot => 

Proof state:
case coe.bot
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
f₁ : α
⊢ g' (↑f₁ ⊔ ⊥) = g' ↑f₁ ⊔ g' ⊥

Next tactic:
rfl
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  intro f₁ f₂
  cases f₁ using WithBot.recBotCoe with
  | bot =>
    rw [bot_sup_eq]
    exact bot_sup_eq.symm
  | coe f₁ =>
    cases f₂ using WithBot.recBotCoe with
    | bot => rfl
    

Proof state:
case coe.coe
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
f₁ f₂ : α
⊢ g' (↑f₁ ⊔ ↑f₂) = g' ↑f₁ ⊔ g' ↑f₂

Next tactic:
| coe f₂ => exact congr_arg _ (g_sup f₁ f₂)
theorem comp_sup'_eq_sup'_comp [SemilatticeSup γ] {s : Finset β} (H : s.Nonempty) {f : β → α}
    (g : α → γ) (g_sup : ∀ x y, g (x ⊔ y) = g x ⊔ g y) : g (s.sup' H f) = s.sup' H (g ∘ f) := by
  rw [← WithBot.coe_eq_coe, coe_sup']
  let g' := WithBot.map g
  show g' ↑(s.sup' H f) = s.sup fun a => g' ↑(f a)
  rw [coe_sup']
  refine' comp_sup_eq_sup_comp g' _ rfl
  intro f₁ f₂
  cases f₁ using WithBot.recBotCoe with
  | bot =>
    rw [bot_sup_eq]
    exact bot_sup_eq.symm
  | coe f₁ =>
    cases f₂ using WithBot.recBotCoe with
    | bot => rfl
    | coe f₂ => 

Proof state:
case coe.coe
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
s✝ : Finset β
H✝ : Finset.Nonempty s✝
f✝ : β → α
inst✝ : SemilatticeSup γ
s : Finset β
H : Finset.Nonempty s
f : β → α
g : α → γ
g_sup : ∀ (x y : α), g (x ⊔ y) = g x ⊔ g y
g' : WithBot α → WithBot γ := WithBot.map g
f₁ f₂ : α
⊢ g' (↑f₁ ⊔ ↑f₂) = g' ↑f₁ ⊔ g' ↑f₂

Next tactic:
exact congr_arg _ (g_sup f₁ f₂)
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
⊢ p (sup' s H f)

Next tactic:
show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
⊢ WithBot.recBotCoe True p ↑(sup' s H f)

Next tactic:
rw [coe_sup']
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
  rw [coe_sup']
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
⊢ WithBot.recBotCoe True p (sup s (WithBot.some ∘ f))

Next tactic:
refine' sup_induction trivial _ hs
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
  rw [coe_sup']
  refine' sup_induction trivial _ hs
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
⊢ ∀ (a₁ : WithBot α),
    WithBot.recBotCoe True p a₁ → ∀ (a₂ : WithBot α), WithBot.recBotCoe True p a₂ → WithBot.recBotCoe True p (a₁ ⊔ a₂)

Next tactic:
rintro (_ | a₁) h₁ a₂ h₂
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
  rw [coe_sup']
  refine' sup_induction trivial _ hs
  rintro (_ | a₁) h₁ a₂ h₂
  · 

Proof state:
case none
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
h₁ : WithBot.recBotCoe True p none
a₂ : WithBot α
h₂ : WithBot.recBotCoe True p a₂
⊢ WithBot.recBotCoe True p (none ⊔ a₂)

Next tactic:
rw [WithBot.none_eq_bot, bot_sup_eq]
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
  rw [coe_sup']
  refine' sup_induction trivial _ hs
  rintro (_ | a₁) h₁ a₂ h₂
  · rw [WithBot.none_eq_bot, bot_sup_eq]
    

Proof state:
case none
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
h₁ : WithBot.recBotCoe True p none
a₂ : WithBot α
h₂ : WithBot.recBotCoe True p a₂
⊢ WithBot.recBotCoe True p a₂

Next tactic:
exact h₂
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
  rw [coe_sup']
  refine' sup_induction trivial _ hs
  rintro (_ | a₁) h₁ a₂ h₂
  · rw [WithBot.none_eq_bot, bot_sup_eq]
    exact h₂
  · 

Proof state:
case some
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
a₁ : α
h₁ : WithBot.recBotCoe True p (some a₁)
a₂ : WithBot α
h₂ : WithBot.recBotCoe True p a₂
⊢ WithBot.recBotCoe True p (some a₁ ⊔ a₂)

Next tactic:
cases a₂ using WithBot.recBotCoe with
    | bot => exact h₁
    | coe a₂ => exact hp a₁ h₁ a₂ h₂
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
  rw [coe_sup']
  refine' sup_induction trivial _ hs
  rintro (_ | a₁) h₁ a₂ h₂
  · rw [WithBot.none_eq_bot, bot_sup_eq]
    exact h₂
  · cases a₂ using WithBot.recBotCoe with
    

Proof state:
case some.bot
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
a₁ : α
h₁ : WithBot.recBotCoe True p (some a₁)
h₂ : WithBot.recBotCoe True p ⊥
⊢ WithBot.recBotCoe True p (some a₁ ⊔ ⊥)

Next tactic:
| bot => exact h₁
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
  rw [coe_sup']
  refine' sup_induction trivial _ hs
  rintro (_ | a₁) h₁ a₂ h₂
  · rw [WithBot.none_eq_bot, bot_sup_eq]
    exact h₂
  · cases a₂ using WithBot.recBotCoe with
    | bot => 

Proof state:
case some.bot
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
a₁ : α
h₁ : WithBot.recBotCoe True p (some a₁)
h₂ : WithBot.recBotCoe True p ⊥
⊢ WithBot.recBotCoe True p (some a₁ ⊔ ⊥)

Next tactic:
exact h₁
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
  rw [coe_sup']
  refine' sup_induction trivial _ hs
  rintro (_ | a₁) h₁ a₂ h₂
  · rw [WithBot.none_eq_bot, bot_sup_eq]
    exact h₂
  · cases a₂ using WithBot.recBotCoe with
    | bot => exact h₁
    

Proof state:
case some.coe
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
a₁ : α
h₁ : WithBot.recBotCoe True p (some a₁)
a₂ : α
h₂ : WithBot.recBotCoe True p ↑a₂
⊢ WithBot.recBotCoe True p (some a₁ ⊔ ↑a₂)

Next tactic:
| coe a₂ => exact hp a₁ h₁ a₂ h₂
theorem sup'_induction {p : α → Prop} (hp : ∀ a₁, p a₁ → ∀ a₂, p a₂ → p (a₁ ⊔ a₂))
    (hs : ∀ b ∈ s, p (f b)) : p (s.sup' H f) := by
  show @WithBot.recBotCoe α (fun _ => Prop) True p ↑(s.sup' H f)
  rw [coe_sup']
  refine' sup_induction trivial _ hs
  rintro (_ | a₁) h₁ a₂ h₂
  · rw [WithBot.none_eq_bot, bot_sup_eq]
    exact h₂
  · cases a₂ using WithBot.recBotCoe with
    | bot => exact h₁
    | coe a₂ => 

Proof state:
case some.coe
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f : β → α
p : α → Prop
hp : ∀ (a₁ : α), p a₁ → ∀ (a₂ : α), p a₂ → p (a₁ ⊔ a₂)
hs : ∀ b ∈ s, p (f b)
a₁ : α
h₁ : WithBot.recBotCoe True p (some a₁)
a₂ : α
h₂ : WithBot.recBotCoe True p ↑a₂
⊢ WithBot.recBotCoe True p (some a₁ ⊔ ↑a₂)

Next tactic:
exact hp a₁ h₁ a₂ h₂
@[congr]
theorem sup'_congr {t : Finset β} {f g : β → α} (h₁ : s = t) (h₂ : ∀ x ∈ s, f x = g x) :
    s.sup' H f = t.sup' (h₁ ▸ H) g := by
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
s : Finset β
H : Finset.Nonempty s
f✝ : β → α
t : Finset β
f g : β → α
h₁ : s = t
h₂ : ∀ x ∈ s, f x = g x
⊢ sup' s H f = sup' t (_ : Finset.Nonempty t) g

Next tactic:
subst s
@[congr]
theorem sup'_congr {t : Finset β} {f g : β → α} (h₁ : s = t) (h₂ : ∀ x ∈ s, f x = g x) :
    s.sup' H f = t.sup' (h₁ ▸ H) g := by
  subst s
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
f✝ : β → α
t : Finset β
f g : β → α
H : Finset.Nonempty t
h₂ : ∀ x ∈ t, f x = g x
⊢ sup' t H f = sup' t (_ : Finset.Nonempty t) g

Next tactic:
refine' eq_of_forall_ge_iff fun c => _
@[congr]
theorem sup'_congr {t : Finset β} {f g : β → α} (h₁ : s = t) (h₂ : ∀ x ∈ s, f x = g x) :
    s.sup' H f = t.sup' (h₁ ▸ H) g := by
  subst s
  refine' eq_of_forall_ge_iff fun c => _
  

Proof state:
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : SemilatticeSup α
f✝ : β → α
t : Finset β
f g : β → α
H : Finset.Nonempty t
h₂ : ∀ x ∈ t, f x = g x
c : α
⊢ sup' t H f ≤ c ↔ sup' t (_ : Finset.Nonempty t) g ≤ c

Next tactic:
simp (config := { contextual := true }) only [sup'_le_iff, h₂]