l3lab/ntp-mathlib huggingface dataset:
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [

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 β'
x y : (α →𝒄 β) × α
h : x ≤ y
⊢ x.1 x.2 ≤ y.1 x.2

Next tactic:
apply h.1
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; 

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 β'
x y : (α →𝒄 β) × α
h : x ≤ y
⊢ y.1 x.2 ≤ y.1 y.2

Next tactic:
apply y.1.monotone h.2
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := 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 β'
⊢ Continuous
    { toFun := fun f => f.1 f.2,
      monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) }

Next tactic:
intro c
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    

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 β'
c : Chain ((α →𝒄 β) × α)
⊢ { toFun := fun f => f.1 f.2,
        monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) }
      (ωSup c) =
    ωSup
      (Chain.map c
        { toFun := fun f => f.1 f.2,
          monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) })

Next tactic:
apply le_antisymm
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · 

Proof state:
case a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
⊢ { toFun := fun f => f.1 f.2,
        monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) }
      (ωSup c) ≤
    ωSup
      (Chain.map c
        { toFun := fun f => f.1 f.2,
          monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) })

Next tactic:
apply ωSup_le
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      

Proof state:
case a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
⊢ ∀ (i : ℕ),
    (Chain.map (Chain.map (Chain.map c OrderHom.fst) toMono) (OrderHom.apply (ωSup c).2)) i ≤
      ωSup
        (Chain.map c
          { toFun := fun f => f.1 f.2,
            monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) })

Next tactic:
intro i
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      

Proof state:
case a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i : ℕ
⊢ (Chain.map (Chain.map (Chain.map c OrderHom.fst) toMono) (OrderHom.apply (ωSup c).2)) i ≤
    ωSup
      (Chain.map c
        { toFun := fun f => f.1 f.2,
          monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) })

Next tactic:
dsimp
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      

Proof state:
case a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i : ℕ
⊢ (c i).1 (ωSup (Chain.map c OrderHom.snd)) ≤
    ωSup
      (Chain.map c { toFun := fun f => f.1 f.2, monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → x.1 x.2 ≤ y.1 y.2) })

Next tactic:
rw [(c _).fst.continuous]
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      

Proof state:
case a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i : ℕ
⊢ ωSup (Chain.map (Chain.map c OrderHom.snd) ↑(c i).1) ≤
    ωSup
      (Chain.map c { toFun := fun f => f.1 f.2, monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → x.1 x.2 ≤ y.1 y.2) })

Next tactic:
apply ωSup_le
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      

Proof state:
case a.a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i : ℕ
⊢ ∀ (i_1 : ℕ),
    (Chain.map (Chain.map c OrderHom.snd) ↑(c i).1) i_1 ≤
      ωSup
        (Chain.map c
          { toFun := fun f => f.1 f.2, monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → x.1 x.2 ≤ y.1 y.2) })

Next tactic:
intro j
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      

Proof state:
case a.a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i j : ℕ
⊢ (Chain.map (Chain.map c OrderHom.snd) ↑(c i).1) j ≤
    ωSup
      (Chain.map c { toFun := fun f => f.1 f.2, monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → x.1 x.2 ≤ y.1 y.2) })

Next tactic:
apply le_ωSup_of_le (max i j)
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      apply le_ωSup_of_le (max i j)
      

Proof state:
case a.a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i j : ℕ
⊢ (Chain.map (Chain.map c OrderHom.snd) ↑(c i).1) j ≤
    (Chain.map c { toFun := fun f => f.1 f.2, monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → x.1 x.2 ≤ y.1 y.2) })
      (max i j)

Next tactic:
apply apply_mono
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      apply le_ωSup_of_le (max i j)
      apply apply_mono
      

Proof state:
case a.a.a.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 β'
c : Chain ((α →𝒄 β) × α)
i j : ℕ
⊢ (c i).1 ≤ (c (max i j)).1
case a.a.a.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 β'
c : Chain ((α →𝒄 β) × α)
i j : ℕ
⊢ (Chain.map c OrderHom.snd) j ≤ (c (max i j)).2

Next tactic:
exact monotone_fst (OrderHom.mono _ (le_max_left _ _))
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      apply le_ωSup_of_le (max i j)
      apply apply_mono
      exact monotone_fst (OrderHom.mono _ (le_max_left _ _))
      

Proof state:
case a.a.a.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 β'
c : Chain ((α →𝒄 β) × α)
i j : ℕ
⊢ (Chain.map c OrderHom.snd) j ≤ (c (max i j)).2

Next tactic:
exact monotone_snd (OrderHom.mono _ (le_max_right _ _))
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      apply le_ωSup_of_le (max i j)
      apply apply_mono
      exact monotone_fst (OrderHom.mono _ (le_max_left _ _))
      exact monotone_snd (OrderHom.mono _ (le_max_right _ _))
    · 

Proof state:
case a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
⊢ ωSup
      (Chain.map c
        { toFun := fun f => f.1 f.2,
          monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) }) ≤
    { toFun := fun f => f.1 f.2,
        monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) }
      (ωSup c)

Next tactic:
apply ωSup_le
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      apply le_ωSup_of_le (max i j)
      apply apply_mono
      exact monotone_fst (OrderHom.mono _ (le_max_left _ _))
      exact monotone_snd (OrderHom.mono _ (le_max_right _ _))
    · apply ωSup_le
      

Proof state:
case a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
⊢ ∀ (i : ℕ),
    (Chain.map c
          { toFun := fun f => f.1 f.2,
            monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) })
        i ≤
      { toFun := fun f => f.1 f.2,
          monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) }
        (ωSup c)

Next tactic:
intro i
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      apply le_ωSup_of_le (max i j)
      apply apply_mono
      exact monotone_fst (OrderHom.mono _ (le_max_left _ _))
      exact monotone_snd (OrderHom.mono _ (le_max_right _ _))
    · apply ωSup_le
      intro i
      

Proof state:
case a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i : ℕ
⊢ (Chain.map c
        { toFun := fun f => f.1 f.2,
          monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) })
      i ≤
    { toFun := fun f => f.1 f.2,
        monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) }
      (ωSup c)

Next tactic:
apply le_ωSup_of_le i
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      apply le_ωSup_of_le (max i j)
      apply apply_mono
      exact monotone_fst (OrderHom.mono _ (le_max_left _ _))
      exact monotone_snd (OrderHom.mono _ (le_max_right _ _))
    · apply ωSup_le
      intro i
      apply le_ωSup_of_le i
      

Proof state:
case a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i : ℕ
⊢ (Chain.map c
        { toFun := fun f => f.1 f.2,
          monotone' := (_ : ∀ (x y : (α →𝒄 β) × α), x ≤ y → (fun f => f.1 f.2) x ≤ (fun f => f.1 f.2) y) })
      i ≤
    (Chain.map (Chain.map (Chain.map c OrderHom.fst) toMono) (OrderHom.apply (ωSup c).2)) i

Next tactic:
dsimp
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      apply le_ωSup_of_le (max i j)
      apply apply_mono
      exact monotone_fst (OrderHom.mono _ (le_max_left _ _))
      exact monotone_snd (OrderHom.mono _ (le_max_right _ _))
    · apply ωSup_le
      intro i
      apply le_ωSup_of_le i
      dsimp
      

Proof state:
case a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i : ℕ
⊢ (c i).1 (c i).2 ≤ (c i).1 (ωSup (Chain.map c OrderHom.snd))

Next tactic:
apply OrderHom.mono _
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      apply le_ωSup_of_le (max i j)
      apply apply_mono
      exact monotone_fst (OrderHom.mono _ (le_max_left _ _))
      exact monotone_snd (OrderHom.mono _ (le_max_right _ _))
    · apply ωSup_le
      intro i
      apply le_ωSup_of_le i
      dsimp
      apply OrderHom.mono _
      

Proof state:
case a.a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i : ℕ
⊢ (c i).2 ≤ ωSup (Chain.map c OrderHom.snd)

Next tactic:
apply le_ωSup_of_le i
/-- The application of continuous functions as a continuous function.  -/
@[simps]
def apply : (α →𝒄 β) × α →𝒄 β where
  toFun f := f.1 f.2
  monotone' x y h := by
    dsimp
    trans y.fst x.snd <;> [apply h.1; apply y.1.monotone h.2]
  cont := by
    intro c
    apply le_antisymm
    · apply ωSup_le
      intro i
      dsimp
      rw [(c _).fst.continuous]
      apply ωSup_le
      intro j
      apply le_ωSup_of_le (max i j)
      apply apply_mono
      exact monotone_fst (OrderHom.mono _ (le_max_left _ _))
      exact monotone_snd (OrderHom.mono _ (le_max_right _ _))
    · apply ωSup_le
      intro i
      apply le_ωSup_of_le i
      dsimp
      apply OrderHom.mono _
      apply le_ωSup_of_le i
      

Proof state:
case a.a.a
α : 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 β'
c : Chain ((α →𝒄 β) × α)
i : ℕ
⊢ (c i).2 ≤ (Chain.map c OrderHom.snd) i

Next tactic:
rfl
theorem ωSup_apply_ωSup (c₀ : Chain (α →𝒄 β)) (c₁ : Chain α) :
    ωSup c₀ (ωSup c₁) = Prod.apply (ωSup (c₀.zip c₁)) := 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 β'
c₀ : Chain (α →𝒄 β)
c₁ : Chain α
⊢ (ωSup c₀) (ωSup c₁) = Prod.apply (ωSup (Chain.zip c₀ c₁))

Next tactic:
simp [Prod.apply_apply, Prod.ωSup_zip]
/-- A family of continuous functions yields a continuous family of functions. -/
@[simps]
def flip {α : Type*} (f : α → β →𝒄 γ) : β →𝒄 α → γ where
  toFun x y := f y x
  monotone' x y h a := (f a).monotone h
  cont := 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 u_5
f : α → β →𝒄 γ
⊢ Continuous { toFun := fun x y => (f y) x, monotone' := (_ : ∀ (x y : β), x ≤ y → ∀ (a : α), (f a) x ≤ (f a) y) }

Next tactic:
intro _
/-- A family of continuous functions yields a continuous family of functions. -/
@[simps]
def flip {α : Type*} (f : α → β →𝒄 γ) : β →𝒄 α → γ where
  toFun x y := f y x
  monotone' x y h a := (f a).monotone h
  cont := by intro _; 

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 u_5
f : α → β →𝒄 γ
c✝ : Chain β
⊢ { toFun := fun x y => (f y) x, monotone' := (_ : ∀ (x y : β), x ≤ y → ∀ (a : α), (f a) x ≤ (f a) y) } (ωSup c✝) =
    ωSup
      (Chain.map c✝
        { toFun := fun x y => (f y) x, monotone' := (_ : ∀ (x y : β), x ≤ y → ∀ (a : α), (f a) x ≤ (f a) y) })

Next tactic:
ext x