l3lab/ntp-mathlib huggingface dataset:
/-- Any complete lattice has an `ω`-CPO structure where the countable supremum is a special case
of arbitrary suprema. -/
instance (priority := 100) [CompleteLattice α] : OmegaCompletePartialOrder α where
  ωSup c := ⨆ i, c i
  ωSup_le := fun ⟨c, _⟩ s hs => by
    simp only [iSup_le_iff, OrderHom.coe_mk] at hs ⊢; intro i; 

Proof state:
α : Type u
inst✝ : CompleteLattice α
x✝ : Chain α
s : α
c : ℕ → α
monotone'✝ : Monotone c
hs : ∀ (i : ℕ), { toFun := c, monotone' := monotone'✝ } i ≤ s
i : ℕ
⊢ { toFun := c, monotone' := monotone'✝ } i ≤ s

Next tactic:
apply hs i
theorem sSup_continuous (s : Set <| α →o β) (hs : ∀ f ∈ s, Continuous f) : Continuous (sSup s) := by
  

Proof state:
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
⊢ Continuous (sSup s)

Next tactic:
intro c
theorem sSup_continuous (s : Set <| α →o β) (hs : ∀ f ∈ s, Continuous f) : Continuous (sSup s) := by
  intro c
  

Proof state:
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
⊢ (sSup s) (ωSup c) = ωSup (Chain.map c (sSup s))

Next tactic:
apply eq_of_forall_ge_iff
theorem sSup_continuous (s : Set <| α →o β) (hs : ∀ f ∈ s, Continuous f) : Continuous (sSup s) := by
  intro c
  apply eq_of_forall_ge_iff
  

Proof state:
case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
⊢ ∀ (c_1 : β), (sSup s) (ωSup c) ≤ c_1 ↔ ωSup (Chain.map c (sSup s)) ≤ c_1

Next tactic:
intro z
theorem sSup_continuous (s : Set <| α →o β) (hs : ∀ f ∈ s, Continuous f) : Continuous (sSup s) := by
  intro c
  apply eq_of_forall_ge_iff
  intro z
  

Proof state:
case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
⊢ (sSup s) (ωSup c) ≤ z ↔ ωSup (Chain.map c (sSup s)) ≤ z

Next tactic:
suffices (∀ f ∈ s, ∀ (n), (f : _) (c n) ≤ z) ↔ ∀ (n), ∀ f ∈ s, (f : _) (c n) ≤ z by
    simpa (config := { contextual := true }) [ωSup_le_iff, hs _ _ _] using this
theorem sSup_continuous (s : Set <| α →o β) (hs : ∀ f ∈ s, Continuous f) : Continuous (sSup s) := by
  intro c
  apply eq_of_forall_ge_iff
  intro z
  suffices (∀ f ∈ s, ∀ (n), (f : _) (c n) ≤ z) ↔ ∀ (n), ∀ f ∈ s, (f : _) (c n) ≤ z by
    

Proof state:
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
this : (∀ f ∈ s, ∀ (n : ℕ), f (c n) ≤ z) ↔ ∀ (n : ℕ), ∀ f ∈ s, f (c n) ≤ z
⊢ (sSup s) (ωSup c) ≤ z ↔ ωSup (Chain.map c (sSup s)) ≤ z

Next tactic:
simpa (config := { contextual := true }) [ωSup_le_iff, hs _ _ _] using this
theorem sSup_continuous (s : Set <| α →o β) (hs : ∀ f ∈ s, Continuous f) : Continuous (sSup s) := by
  intro c
  apply eq_of_forall_ge_iff
  intro z
  suffices (∀ f ∈ s, ∀ (n), (f : _) (c n) ≤ z) ↔ ∀ (n), ∀ f ∈ s, (f : _) (c n) ≤ z by
    simpa (config := { contextual := true }) [ωSup_le_iff, hs _ _ _] using this
  

Proof state:
case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
⊢ (∀ f ∈ s, ∀ (n : ℕ), f (c n) ≤ z) ↔ ∀ (n : ℕ), ∀ f ∈ s, f (c n) ≤ z

Next tactic:
exact ⟨fun H n f hf => H f hf n, fun H f hf n => H n f hf⟩
theorem sSup_continuous' (s : Set (α → β)) (hc : ∀ f ∈ s, Continuous' f) :
    Continuous' (sSup s) := by
  

Proof state:
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α → β)
hc : ∀ f ∈ s, Continuous' f
⊢ Continuous' (sSup s)

Next tactic:
lift s to Set (α →o β) using fun f hf => (hc f hf).to_monotone
theorem sSup_continuous' (s : Set (α → β)) (hc : ∀ f ∈ s, Continuous' f) :
    Continuous' (sSup s) := by
  lift s to Set (α →o β) using fun f hf => (hc f hf).to_monotone
  

Proof state:
case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ f ∈ FunLike.coe '' s, Continuous' f
⊢ Continuous' (sSup (FunLike.coe '' s))

Next tactic:
simp only [Set.ball_image_iff, continuous'_coe] at hc
theorem sSup_continuous' (s : Set (α → β)) (hc : ∀ f ∈ s, Continuous' f) :
    Continuous' (sSup s) := by
  lift s to Set (α →o β) using fun f hf => (hc f hf).to_monotone
  simp only [Set.ball_image_iff, continuous'_coe] at hc
  

Proof state:
case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ x ∈ s, Continuous x
⊢ Continuous' (sSup (FunLike.coe '' s))

Next tactic:
rw [sSup_image]
theorem sSup_continuous' (s : Set (α → β)) (hc : ∀ f ∈ s, Continuous' f) :
    Continuous' (sSup s) := by
  lift s to Set (α →o β) using fun f hf => (hc f hf).to_monotone
  simp only [Set.ball_image_iff, continuous'_coe] at hc
  rw [sSup_image]
  

Proof state:
case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ x ∈ s, Continuous x
⊢ Continuous' (⨆ a ∈ s, ⇑a)

Next tactic:
norm_cast
theorem sSup_continuous' (s : Set (α → β)) (hc : ∀ f ∈ s, Continuous' f) :
    Continuous' (sSup s) := by
  lift s to Set (α →o β) using fun f hf => (hc f hf).to_monotone
  simp only [Set.ball_image_iff, continuous'_coe] at hc
  rw [sSup_image]
  norm_cast
  

Proof state:
case intro
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hc : ∀ x ∈ s, Continuous x
⊢ Continuous (⨆ i ∈ s, i)

Next tactic:
exact iSup_continuous fun f => iSup_continuous fun hf => hc f hf
theorem sup_continuous {f g : α →o β} (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊔ g) := by
  

Proof state:
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ Continuous (f ⊔ g)

Next tactic:
rw [← sSup_pair]
theorem sup_continuous {f g : α →o β} (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊔ g) := by
  rw [← sSup_pair]; 

Proof state:
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ Continuous (sSup {f, g})

Next tactic:
apply sSup_continuous
theorem sup_continuous {f g : α →o β} (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊔ g) := by
  rw [← sSup_pair]; apply sSup_continuous
  

Proof state:
case hs
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ ∀ f_1 ∈ {f, g}, Continuous f_1

Next tactic:
rintro f (rfl | rfl | _)
theorem sup_continuous {f g : α →o β} (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊔ g) := by
  rw [← sSup_pair]; apply sSup_continuous
  rintro f (rfl | rfl | _) <;> 

Proof state:
case hs.inl
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
g : α →o β
hg : Continuous g
f : α →o β
hf : Continuous f
⊢ Continuous f

Next tactic:
assumption
theorem sup_continuous {f g : α →o β} (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊔ g) := by
  rw [← sSup_pair]; apply sSup_continuous
  rintro f (rfl | rfl | _) <;> 

Proof state:
case hs.inr.refl
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ Continuous g

Next tactic:
assumption
theorem top_continuous : Continuous (⊤ : α →o β) := by
  

Proof state:
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ Continuous ⊤

Next tactic:
intro c
theorem top_continuous : Continuous (⊤ : α →o β) := by
  intro c; 

Proof state:
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
⊢ ⊤ (ωSup c) = ωSup (Chain.map c ⊤)

Next tactic:
apply eq_of_forall_ge_iff
theorem top_continuous : Continuous (⊤ : α →o β) := by
  intro c; apply eq_of_forall_ge_iff; 

Proof state:
case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
⊢ ∀ (c_1 : β), ⊤ (ωSup c) ≤ c_1 ↔ ωSup (Chain.map c ⊤) ≤ c_1

Next tactic:
intro z
theorem top_continuous : Continuous (⊤ : α →o β) := by
  intro c; apply eq_of_forall_ge_iff; intro z
  

Proof state:
case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
c : Chain α
z : β
⊢ ⊤ (ωSup c) ≤ z ↔ ωSup (Chain.map c ⊤) ≤ z

Next tactic:
simp only [OrderHom.instTopOrderHom_top, OrderHom.const_coe_coe, Function.const, top_le_iff,
    ωSup_le_iff, Chain.map_coe, Function.comp, forall_const]
theorem bot_continuous : Continuous (⊥ : α →o β) := by
  

Proof state:
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ Continuous ⊥

Next tactic:
rw [← sSup_empty]
theorem bot_continuous : Continuous (⊥ : α →o β) := by
  rw [← sSup_empty]
  

Proof state:
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
⊢ Continuous (sSup ∅)

Next tactic:
exact sSup_continuous _ fun f hf => hf.elim
theorem inf_continuous (f g : α →o β) (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊓ g) := by
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLinearOrder β
f g : α →o β
hf : Continuous f
hg : Continuous g
⊢ Continuous (f ⊓ g)

Next tactic:
refine' fun c => eq_of_forall_ge_iff fun z => _
theorem inf_continuous (f g : α →o β) (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊓ g) := by
  refine' fun c => eq_of_forall_ge_iff fun z => _
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLinearOrder β
f g : α →o β
hf : Continuous f
hg : Continuous g
c : Chain α
z : β
⊢ (f ⊓ g) (ωSup c) ≤ z ↔ ωSup (Chain.map c (f ⊓ g)) ≤ z

Next tactic:
simp only [inf_le_iff, hf c, hg c, ωSup_le_iff, ← forall_or_left, ← forall_or_right,
             Chain.map_coe, OrderHom.coe_inf, ge_iff_le, Pi.inf_apply, Function.comp]
theorem inf_continuous (f g : α →o β) (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊓ g) := by
  refine' fun c => eq_of_forall_ge_iff fun z => _
  simp only [inf_le_iff, hf c, hg c, ωSup_le_iff, ← forall_or_left, ← forall_or_right,
             Chain.map_coe, OrderHom.coe_inf, ge_iff_le, Pi.inf_apply, Function.comp]
  

Proof state:
α : Type u_1
β : Type u_2
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLinearOrder β
f g : α →o β
hf : Continuous f
hg : Continuous g
c : Chain α
z : β
⊢ (∀ (x x_1 : ℕ), f (c x_1) ≤ z ∨ g (c x) ≤ z) ↔ ∀ (i : ℕ), f (c i) ≤ z ∨ g (c i) ≤ z

Next tactic:
exact ⟨λ h _ => h _ _, λ h i j => (h (max j i)).imp (le_trans $ f.mono $ c.mono $ le_max_left _ _)
    (le_trans $ g.mono $ c.mono $ le_max_right _ _)⟩
instance : OrderHomClass (α →𝒄 β) α β where
  coe f := f.toFun
  coe_injective' := by 

Proof state:
α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
⊢ Function.Injective fun f => f.toFun

Next tactic:
rintro ⟨⟩ ⟨⟩ h
instance : OrderHomClass (α →𝒄 β) α β where
  coe f := f.toFun
  coe_injective' := by rintro ⟨⟩ ⟨⟩ h; 

Proof state:
case mk.mk
α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
toOrderHom✝¹ : α →o β
cont✝¹ : Continuous toOrderHom✝¹
toOrderHom✝ : α →o β
cont✝ : Continuous toOrderHom✝
h :
  (fun f => f.toFun) { toOrderHom := toOrderHom✝¹, cont := cont✝¹ } =
    (fun f => f.toFun) { toOrderHom := toOrderHom✝, cont := cont✝ }
⊢ { toOrderHom := toOrderHom✝¹, cont := cont✝¹ } = { toOrderHom := toOrderHom✝, cont := cont✝ }

Next tactic:
congr
instance : OrderHomClass (α →𝒄 β) α β where
  coe f := f.toFun
  coe_injective' := by rintro ⟨⟩ ⟨⟩ h; congr; 

Proof state:
case mk.mk.e_toOrderHom
α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
toOrderHom✝¹ : α →o β
cont✝¹ : Continuous toOrderHom✝¹
toOrderHom✝ : α →o β
cont✝ : Continuous toOrderHom✝
h :
  (fun f => f.toFun) { toOrderHom := toOrderHom✝¹, cont := cont✝¹ } =
    (fun f => f.toFun) { toOrderHom := toOrderHom✝, cont := cont✝ }
⊢ toOrderHom✝¹ = toOrderHom✝

Next tactic:
exact FunLike.ext' h
instance : PartialOrder (α →𝒄 β) :=
  (PartialOrder.lift fun f => f.toOrderHom.toFun) <| by 

Proof state:
α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
⊢ Function.Injective fun f => f.toFun

Next tactic:
rintro ⟨⟨⟩⟩ ⟨⟨⟩⟩ h
instance : PartialOrder (α →𝒄 β) :=
  (PartialOrder.lift fun f => f.toOrderHom.toFun) <| by rintro ⟨⟨⟩⟩ ⟨⟨⟩⟩ h; 

Proof state:
case mk.mk.mk.mk
α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
toFun✝¹ : α → β
monotone'✝¹ : Monotone toFun✝¹
cont✝¹ : Continuous { toFun := toFun✝¹, monotone' := monotone'✝¹ }
toFun✝ : α → β
monotone'✝ : Monotone toFun✝
cont✝ : Continuous { toFun := toFun✝, monotone' := monotone'✝ }
h :
  (fun f => f.toFun) { toOrderHom := { toFun := toFun✝¹, monotone' := monotone'✝¹ }, cont := cont✝¹ } =
    (fun f => f.toFun) { toOrderHom := { toFun := toFun✝, monotone' := monotone'✝ }, cont := cont✝ }
⊢ { toOrderHom := { toFun := toFun✝¹, monotone' := monotone'✝¹ }, cont := cont✝¹ } =
    { toOrderHom := { toFun := toFun✝, monotone' := monotone'✝ }, cont := cont✝ }

Next tactic:
congr
theorem ite_continuous' {p : Prop} [hp : Decidable p] (f g : α → β) (hf : Continuous' f)
    (hg : Continuous' g) : Continuous' fun x => if p then f x else g x := by
  

Proof state:
α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
p : Prop
hp : Decidable p
f g : α → β
hf : Continuous' f
hg : Continuous' g
⊢ Continuous' fun x => if p then f x else g x

Next tactic:
split_ifs
theorem ite_continuous' {p : Prop} [hp : Decidable p] (f g : α → β) (hf : Continuous' f)
    (hg : Continuous' g) : Continuous' fun x => if p then f x else g x := by
  split_ifs <;> 

Proof state:
case pos
α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
p : Prop
hp : Decidable p
f g : α → β
hf : Continuous' f
hg : Continuous' g
h✝ : p
⊢ Continuous' fun x => f x

Next tactic:
simp [*]
theorem ite_continuous' {p : Prop} [hp : Decidable p] (f g : α → β) (hf : Continuous' f)
    (hg : Continuous' g) : Continuous' fun x => if p then f x else g x := by
  split_ifs <;> 

Proof state:
case neg
α : Type u
α' : Type u_1
β : Type v
β' : Type u_2
γ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β
inst✝³ : OmegaCompletePartialOrder γ
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
p : Prop
hp : Decidable p
f g : α → β
hf : Continuous' f
hg : Continuous' g
h✝ : ¬p
⊢ Continuous' fun x => g x

Next tactic:
simp [*]
theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.bind g)) = ωSup (c.map f) >>= ωSup (c.map g) := by
  

Proof state:
α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
c : Chain α
f : α →o Part β
g : α →o β → Part γ
⊢ ωSup (Chain.map c (OrderHom.bind f g)) = ωSup (Chain.map c f) >>= ωSup (Chain.map c g)

Next tactic:
apply eq_of_forall_ge_iff
theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.bind g)) = ωSup (c.map f) >>= ωSup (c.map g) := by
  apply eq_of_forall_ge_iff; 

Proof state:
case H
α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
c : Chain α
f : α →o Part β
g : α →o β → Part γ
⊢ ∀ (c_1 : Part γ), ωSup (Chain.map c (OrderHom.bind f g)) ≤ c_1 ↔ ωSup (Chain.map c f) >>= ωSup (Chain.map c g) ≤ c_1

Next tactic:
intro x
theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.bind g)) = ωSup (c.map f) >>= ωSup (c.map g) := by
  apply eq_of_forall_ge_iff; intro x
  

Proof state:
case H
α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
c : Chain α
f : α →o Part β
g : α →o β → Part γ
x : Part γ
⊢ ωSup (Chain.map c (OrderHom.bind f g)) ≤ x ↔ ωSup (Chain.map c f) >>= ωSup (Chain.map c g) ≤ x

Next tactic:
simp only [ωSup_le_iff, Part.bind_le, Chain.mem_map_iff, and_imp, OrderHom.bind_coe, exists_imp]
theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.bind g)) = ωSup (c.map f) >>= ωSup (c.map g) := by
  apply eq_of_forall_ge_iff; intro x
  simp only [ωSup_le_iff, Part.bind_le, Chain.mem_map_iff, and_imp, OrderHom.bind_coe, exists_imp]
  

Proof state:
case H
α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
c : Chain α
f : α →o Part β
g : α →o β → Part γ
x : Part γ
⊢ (∀ (i : ℕ), (Chain.map c (OrderHom.bind f g)) i ≤ x) ↔ ∀ a ∈ ωSup (Chain.map c f), ωSup (Chain.map c g) a ≤ x

Next tactic:
constructor
theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.bind g)) = ωSup (c.map f) >>= ωSup (c.map g) := by
  apply eq_of_forall_ge_iff; intro x
  simp only [ωSup_le_iff, Part.bind_le, Chain.mem_map_iff, and_imp, OrderHom.bind_coe, exists_imp]
  constructor <;> 

Proof state:
case H.mp
α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
c : Chain α
f : α →o Part β
g : α →o β → Part γ
x : Part γ
⊢ (∀ (i : ℕ), (Chain.map c (OrderHom.bind f g)) i ≤ x) → ∀ a ∈ ωSup (Chain.map c f), ωSup (Chain.map c g) a ≤ x

Next tactic:
intro h'''
theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.bind g)) = ωSup (c.map f) >>= ωSup (c.map g) := by
  apply eq_of_forall_ge_iff; intro x
  simp only [ωSup_le_iff, Part.bind_le, Chain.mem_map_iff, and_imp, OrderHom.bind_coe, exists_imp]
  constructor <;> 

Proof state:
case H.mpr
α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
c : Chain α
f : α →o Part β
g : α →o β → Part γ
x : Part γ
⊢ (∀ a ∈ ωSup (Chain.map c f), ωSup (Chain.map c g) a ≤ x) → ∀ (i : ℕ), (Chain.map c (OrderHom.bind f g)) i ≤ x

Next tactic:
intro h'''
theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.bind g)) = ωSup (c.map f) >>= ωSup (c.map g) := by
  apply eq_of_forall_ge_iff; intro x
  simp only [ωSup_le_iff, Part.bind_le, Chain.mem_map_iff, and_imp, OrderHom.bind_coe, exists_imp]
  constructor <;> intro h'''
  · 

Proof state:
case H.mp
α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
c : Chain α
f : α →o Part β
g : α →o β → Part γ
x : Part γ
h''' : ∀ (i : ℕ), (Chain.map c (OrderHom.bind f g)) i ≤ x
⊢ ∀ a ∈ ωSup (Chain.map c f), ωSup (Chain.map c g) a ≤ x

Next tactic:
intro b hb
theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.bind g)) = ωSup (c.map f) >>= ωSup (c.map g) := by
  apply eq_of_forall_ge_iff; intro x
  simp only [ωSup_le_iff, Part.bind_le, Chain.mem_map_iff, and_imp, OrderHom.bind_coe, exists_imp]
  constructor <;> intro h'''
  · intro b hb
    

Proof state:
case H.mp
α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
c : Chain α
f : α →o Part β
g : α →o β → Part γ
x : Part γ
h''' : ∀ (i : ℕ), (Chain.map c (OrderHom.bind f g)) i ≤ x
b : β
hb : b ∈ ωSup (Chain.map c f)
⊢ ωSup (Chain.map c g) b ≤ x

Next tactic:
apply ωSup_le _ _ _
theorem ωSup_bind {β γ : Type v} (c : Chain α) (f : α →o Part β) (g : α →o β → Part γ) :
    ωSup (c.map (f.bind g)) = ωSup (c.map f) >>= ωSup (c.map g) := by
  apply eq_of_forall_ge_iff; intro x
  simp only [ωSup_le_iff, Part.bind_le, Chain.mem_map_iff, and_imp, OrderHom.bind_coe, exists_imp]
  constructor <;> intro h'''
  · intro b hb
    apply ωSup_le _ _ _
    

Proof state:
α : Type u
α' : Type u_1
β✝ : Type v
β' : Type u_2
γ✝ : Type u_3
φ : Type u_4
inst✝⁵ : OmegaCompletePartialOrder α
inst✝⁴ : OmegaCompletePartialOrder β✝
inst✝³ : OmegaCompletePartialOrder γ✝
inst✝² : OmegaCompletePartialOrder φ
inst✝¹ : OmegaCompletePartialOrder α'
inst✝ : OmegaCompletePartialOrder β'
β γ : Type v
c : Chain α
f : α →o Part β
g : α →o β → Part γ
x : Part γ
h''' : ∀ (i : ℕ), (Chain.map c (OrderHom.bind f g)) i ≤ x
b : β
hb : b ∈ ωSup (Chain.map c f)
⊢ ∀ (i : ℕ), (Chain.map (Chain.map c g) (Pi.evalOrderHom b)) i ≤ x

Next tactic:
rintro i y hy