l3lab/ntp-mathlib huggingface dataset:
theorem eq_of_chain {c : Chain (Part α)} {a b : α} (ha : some a ∈ c) (hb : some b ∈ c) : a = b := by
  cases' ha with i ha; replace ha := ha.symm
  cases' hb with j hb; replace hb := hb.symm
  rw [eq_some_iff] at ha hb
  

Proof state:
case intro.intro
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ c i
j : ℕ
hb : b ∈ c j
⊢ a = b

Next tactic:
rcases le_total i j with hij | hji
theorem eq_of_chain {c : Chain (Part α)} {a b : α} (ha : some a ∈ c) (hb : some b ∈ c) : a = b := by
  cases' ha with i ha; replace ha := ha.symm
  cases' hb with j hb; replace hb := hb.symm
  rw [eq_some_iff] at ha hb
  rcases le_total i j with hij | hji
  · 

Proof state:
case intro.intro.inl
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ c i
j : ℕ
hb : b ∈ c j
hij : i ≤ j
⊢ a = b

Next tactic:
have := c.monotone hij _ ha
theorem eq_of_chain {c : Chain (Part α)} {a b : α} (ha : some a ∈ c) (hb : some b ∈ c) : a = b := by
  cases' ha with i ha; replace ha := ha.symm
  cases' hb with j hb; replace hb := hb.symm
  rw [eq_some_iff] at ha hb
  rcases le_total i j with hij | hji
  · have := c.monotone hij _ ha; 

Proof state:
case intro.intro.inl
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ c i
j : ℕ
hb : b ∈ c j
hij : i ≤ j
this : a ∈ c j
⊢ a = b

Next tactic:
apply mem_unique this hb
theorem eq_of_chain {c : Chain (Part α)} {a b : α} (ha : some a ∈ c) (hb : some b ∈ c) : a = b := by
  cases' ha with i ha; replace ha := ha.symm
  cases' hb with j hb; replace hb := hb.symm
  rw [eq_some_iff] at ha hb
  rcases le_total i j with hij | hji
  · have := c.monotone hij _ ha; apply mem_unique this hb
  · 

Proof state:
case intro.intro.inr
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ c i
j : ℕ
hb : b ∈ c j
hji : j ≤ i
⊢ a = b

Next tactic:
have := c.monotone hji _ hb
theorem eq_of_chain {c : Chain (Part α)} {a b : α} (ha : some a ∈ c) (hb : some b ∈ c) : a = b := by
  cases' ha with i ha; replace ha := ha.symm
  cases' hb with j hb; replace hb := hb.symm
  rw [eq_some_iff] at ha hb
  rcases le_total i j with hij | hji
  · have := c.monotone hij _ ha; apply mem_unique this hb
  · have := c.monotone hji _ hb; 

Proof state:
case intro.intro.inr
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ c i
j : ℕ
hb : b ∈ c j
hji : j ≤ i
this : b ∈ c i
⊢ a = b

Next tactic:
apply Eq.symm
theorem eq_of_chain {c : Chain (Part α)} {a b : α} (ha : some a ∈ c) (hb : some b ∈ c) : a = b := by
  cases' ha with i ha; replace ha := ha.symm
  cases' hb with j hb; replace hb := hb.symm
  rw [eq_some_iff] at ha hb
  rcases le_total i j with hij | hji
  · have := c.monotone hij _ ha; apply mem_unique this hb
  · have := c.monotone hji _ hb; apply Eq.symm; 

Proof state:
case intro.intro.inr.h
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a b : α
i : ℕ
ha : a ∈ c i
j : ℕ
hb : b ∈ c j
hji : j ≤ i
this : b ∈ c i
⊢ b = a

Next tactic:
apply mem_unique this ha
theorem mem_chain_of_mem_ωSup {c : Chain (Part α)} {a : α} (h : a ∈ Part.ωSup c) : some a ∈ c := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h : a ∈ Part.ωSup c
⊢ some a ∈ c

Next tactic:
simp only [Part.ωSup] at h
theorem mem_chain_of_mem_ωSup {c : Chain (Part α)} {a : α} (h : a ∈ Part.ωSup c) : some a ∈ c := by
  simp only [Part.ωSup] at h; 

Proof state:
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h : a ∈ if h : ∃ a, some a ∈ c then some (choose h) else none
⊢ some a ∈ c

Next tactic:
split_ifs at h with h_1
theorem mem_chain_of_mem_ωSup {c : Chain (Part α)} {a : α} (h : a ∈ Part.ωSup c) : some a ∈ c := by
  simp only [Part.ωSup] at h; split_ifs at h with h_1
  · 

Proof state:
case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : a ∈ some (choose h_1)
⊢ some a ∈ c

Next tactic:
have h' := Classical.choose_spec h_1
theorem mem_chain_of_mem_ωSup {c : Chain (Part α)} {a : α} (h : a ∈ Part.ωSup c) : some a ∈ c := by
  simp only [Part.ωSup] at h; split_ifs at h with h_1
  · have h' := Classical.choose_spec h_1
    

Proof state:
case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : a ∈ some (choose h_1)
h' : some (choose h_1) ∈ c
⊢ some a ∈ c

Next tactic:
rw [← eq_some_iff] at h
theorem mem_chain_of_mem_ωSup {c : Chain (Part α)} {a : α} (h : a ∈ Part.ωSup c) : some a ∈ c := by
  simp only [Part.ωSup] at h; split_ifs at h with h_1
  · have h' := Classical.choose_spec h_1
    rw [← eq_some_iff] at h
    

Proof state:
case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : some (choose h_1) = some a
h' : some (choose h_1) ∈ c
⊢ some a ∈ c

Next tactic:
rw [← h]
theorem mem_chain_of_mem_ωSup {c : Chain (Part α)} {a : α} (h : a ∈ Part.ωSup c) : some a ∈ c := by
  simp only [Part.ωSup] at h; split_ifs at h with h_1
  · have h' := Classical.choose_spec h_1
    rw [← eq_some_iff] at h
    rw [← h]
    

Proof state:
case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ∃ a, some a ∈ c
h : some (choose h_1) = some a
h' : some (choose h_1) ∈ c
⊢ some (choose h_1) ∈ c

Next tactic:
exact h'
theorem mem_chain_of_mem_ωSup {c : Chain (Part α)} {a : α} (h : a ∈ Part.ωSup c) : some a ∈ c := by
  simp only [Part.ωSup] at h; split_ifs at h with h_1
  · have h' := Classical.choose_spec h_1
    rw [← eq_some_iff] at h
    rw [← h]
    exact h'
  · 

Proof state:
case neg
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
a : α
h_1 : ¬∃ a, some a ∈ c
h : a ∈ none
⊢ some a ∈ c

Next tactic:
rcases h with ⟨⟨⟩⟩
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    

Proof state:
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
i : ℕ
⊢ c i ≤ Part.ωSup c

Next tactic:
intro x hx
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    intro x hx
    

Proof state:
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
i : ℕ
x : α
hx : x ∈ c i
⊢ x ∈ Part.ωSup c

Next tactic:
rw [← eq_some_iff] at hx ⊢
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    intro x hx
    rw [← eq_some_iff] at hx ⊢
    

Proof state:
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
i : ℕ
x : α
hx : c i = some x
⊢ Part.ωSup c = some x

Next tactic:
rw [ωSup_eq_some, ← hx]
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    intro x hx
    rw [← eq_some_iff] at hx ⊢
    rw [ωSup_eq_some, ← hx]
    

Proof state:
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
i : ℕ
x : α
hx : c i = some x
⊢ some x ∈ c

Next tactic:
rw [← hx]
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    intro x hx
    rw [← eq_some_iff] at hx ⊢
    rw [ωSup_eq_some, ← hx]
    rw [← hx]
    

Proof state:
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
i : ℕ
x : α
hx : c i = some x
⊢ c i ∈ c

Next tactic:
exact ⟨i, rfl⟩
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    intro x hx
    rw [← eq_some_iff] at hx ⊢
    rw [ωSup_eq_some, ← hx]
    rw [← hx]
    exact ⟨i, rfl⟩
  ωSup_le := by
    

Proof state:
α : Type u
β : Type v
γ : Type u_1
⊢ ∀ (c : Chain (Part α)) (x : Part α), (∀ (i : ℕ), c i ≤ x) → Part.ωSup c ≤ x

Next tactic:
rintro c x hx a ha
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    intro x hx
    rw [← eq_some_iff] at hx ⊢
    rw [ωSup_eq_some, ← hx]
    rw [← hx]
    exact ⟨i, rfl⟩
  ωSup_le := by
    rintro c x hx a ha
    

Proof state:
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
x : Part α
hx : ∀ (i : ℕ), c i ≤ x
a : α
ha : a ∈ Part.ωSup c
⊢ a ∈ x

Next tactic:
replace ha := mem_chain_of_mem_ωSup ha
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    intro x hx
    rw [← eq_some_iff] at hx ⊢
    rw [ωSup_eq_some, ← hx]
    rw [← hx]
    exact ⟨i, rfl⟩
  ωSup_le := by
    rintro c x hx a ha
    replace ha := mem_chain_of_mem_ωSup ha
    

Proof state:
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
x : Part α
hx : ∀ (i : ℕ), c i ≤ x
a : α
ha : some a ∈ c
⊢ a ∈ x

Next tactic:
cases' ha with i ha
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    intro x hx
    rw [← eq_some_iff] at hx ⊢
    rw [ωSup_eq_some, ← hx]
    rw [← hx]
    exact ⟨i, rfl⟩
  ωSup_le := by
    rintro c x hx a ha
    replace ha := mem_chain_of_mem_ωSup ha
    cases' ha with i ha
    

Proof state:
case intro
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
x : Part α
hx : ∀ (i : ℕ), c i ≤ x
a : α
i : ℕ
ha : some a = c i
⊢ a ∈ x

Next tactic:
apply hx i
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    intro x hx
    rw [← eq_some_iff] at hx ⊢
    rw [ωSup_eq_some, ← hx]
    rw [← hx]
    exact ⟨i, rfl⟩
  ωSup_le := by
    rintro c x hx a ha
    replace ha := mem_chain_of_mem_ωSup ha
    cases' ha with i ha
    apply hx i
    

Proof state:
case intro.a
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
x : Part α
hx : ∀ (i : ℕ), c i ≤ x
a : α
i : ℕ
ha : some a = c i
⊢ a ∈ c i

Next tactic:
rw [← ha]
noncomputable instance omegaCompletePartialOrder :
    OmegaCompletePartialOrder (Part α) where
  ωSup := Part.ωSup
  le_ωSup c i := by
    intro x hx
    rw [← eq_some_iff] at hx ⊢
    rw [ωSup_eq_some, ← hx]
    rw [← hx]
    exact ⟨i, rfl⟩
  ωSup_le := by
    rintro c x hx a ha
    replace ha := mem_chain_of_mem_ωSup ha
    cases' ha with i ha
    apply hx i
    rw [← ha]
    

Proof state:
case intro.a
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
x : Part α
hx : ∀ (i : ℕ), c i ≤ x
a : α
i : ℕ
ha : some a = c i
⊢ a ∈ some a

Next tactic:
apply mem_some
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
⊢ x ∈ ωSup c ↔ some x ∈ c

Next tactic:
simp only [ωSup, Part.ωSup]
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  

Proof state:
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
⊢ (x ∈ if h : ∃ a, some a ∈ c then some (choose h) else none) ↔ some x ∈ c

Next tactic:
constructor
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · 

Proof state:
case mp
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
⊢ (x ∈ if h : ∃ a, some a ∈ c then some (choose h) else none) → some x ∈ c

Next tactic:
split_ifs with h
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    

Proof state:
case pos
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : ∃ a, some a ∈ c
⊢ x ∈ some (choose h) → some x ∈ c
case neg α : Type u β : Type v γ : Type u_1 x : α c : Chain (Part α) h : ¬∃ a, some a ∈ c ⊢ x ∈ none → some x ∈ c

Next tactic:
swap
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    

Proof state:
case neg
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : ¬∃ a, some a ∈ c
⊢ x ∈ none → some x ∈ c
case pos
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : ∃ a, some a ∈ c
⊢ x ∈ some (choose h) → some x ∈ c

Next tactic:
rintro ⟨⟨⟩⟩
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    

Proof state:
case pos
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : ∃ a, some a ∈ c
⊢ x ∈ some (choose h) → some x ∈ c

Next tactic:
intro h'
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    intro h'
    

Proof state:
case pos
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : ∃ a, some a ∈ c
h' : x ∈ some (choose h)
⊢ some x ∈ c

Next tactic:
have hh := Classical.choose_spec h
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    intro h'
    have hh := Classical.choose_spec h
    

Proof state:
case pos
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : ∃ a, some a ∈ c
h' : x ∈ some (choose h)
hh : some (choose h) ∈ c
⊢ some x ∈ c

Next tactic:
simp only [mem_some_iff] at h'
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    intro h'
    have hh := Classical.choose_spec h
    simp only [mem_some_iff] at h'
    

Proof state:
case pos
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : ∃ a, some a ∈ c
hh : some (choose h) ∈ c
h' : x = choose h
⊢ some x ∈ c

Next tactic:
subst x
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    intro h'
    have hh := Classical.choose_spec h
    simp only [mem_some_iff] at h'
    subst x
    

Proof state:
case pos
α : Type u
β : Type v
γ : Type u_1
c : Chain (Part α)
h : ∃ a, some a ∈ c
hh : some (choose h) ∈ c
⊢ some (choose h) ∈ c

Next tactic:
exact hh
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    intro h'
    have hh := Classical.choose_spec h
    simp only [mem_some_iff] at h'
    subst x
    exact hh
  · 

Proof state:
case mpr
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
⊢ some x ∈ c → x ∈ if h : ∃ a, some a ∈ c then some (choose h) else none

Next tactic:
intro h
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    intro h'
    have hh := Classical.choose_spec h
    simp only [mem_some_iff] at h'
    subst x
    exact hh
  · intro h
    

Proof state:
case mpr
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : some x ∈ c
⊢ x ∈ if h : ∃ a, some a ∈ c then some (choose h) else none

Next tactic:
have h' : ∃ a : α, some a ∈ c := ⟨_, h⟩
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    intro h'
    have hh := Classical.choose_spec h
    simp only [mem_some_iff] at h'
    subst x
    exact hh
  · intro h
    have h' : ∃ a : α, some a ∈ c := ⟨_, h⟩
    

Proof state:
case mpr
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : some x ∈ c
h' : ∃ a, some a ∈ c
⊢ x ∈ if h : ∃ a, some a ∈ c then some (choose h) else none

Next tactic:
rw [dif_pos h']
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    intro h'
    have hh := Classical.choose_spec h
    simp only [mem_some_iff] at h'
    subst x
    exact hh
  · intro h
    have h' : ∃ a : α, some a ∈ c := ⟨_, h⟩
    rw [dif_pos h']
    

Proof state:
case mpr
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : some x ∈ c
h' : ∃ a, some a ∈ c
⊢ x ∈ some (choose h')

Next tactic:
have hh := Classical.choose_spec h'
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    intro h'
    have hh := Classical.choose_spec h
    simp only [mem_some_iff] at h'
    subst x
    exact hh
  · intro h
    have h' : ∃ a : α, some a ∈ c := ⟨_, h⟩
    rw [dif_pos h']
    have hh := Classical.choose_spec h'
    

Proof state:
case mpr
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : some x ∈ c
h' : ∃ a, some a ∈ c
hh : some (choose h') ∈ c
⊢ x ∈ some (choose h')

Next tactic:
rw [eq_of_chain hh h]
theorem mem_ωSup (x : α) (c : Chain (Part α)) : x ∈ ωSup c ↔ some x ∈ c := by
  simp only [ωSup, Part.ωSup]
  constructor
  · split_ifs with h
    swap
    rintro ⟨⟨⟩⟩
    intro h'
    have hh := Classical.choose_spec h
    simp only [mem_some_iff] at h'
    subst x
    exact hh
  · intro h
    have h' : ∃ a : α, some a ∈ c := ⟨_, h⟩
    rw [dif_pos h']
    have hh := Classical.choose_spec h'
    rw [eq_of_chain hh h]
    

Proof state:
case mpr
α : Type u
β : Type v
γ : Type u_1
x : α
c : Chain (Part α)
h : some x ∈ c
h' : ∃ a, some a ∈ c
hh : some (choose h') ∈ c
⊢ x ∈ some x

Next tactic:
simp
instance [∀ a, OmegaCompletePartialOrder (β a)] :
    OmegaCompletePartialOrder (∀ a, β a) where
  ωSup c a := ωSup (c.map (Pi.evalOrderHom a))
  ωSup_le c f hf a :=
    ωSup_le _ _ <| by
      

Proof state:
α : Type u_1
β : α → Type u_2
γ : Type u_3
inst✝ : (a : α) → OmegaCompletePartialOrder (β a)
c : Chain ((a : α) → β a)
f : (a : α) → β a
hf : ∀ (i : ℕ), c i ≤ f
a : α
⊢ ∀ (i : ℕ), (map c (evalOrderHom a)) i ≤ f a

Next tactic:
rintro i
instance [∀ a, OmegaCompletePartialOrder (β a)] :
    OmegaCompletePartialOrder (∀ a, β a) where
  ωSup c a := ωSup (c.map (Pi.evalOrderHom a))
  ωSup_le c f hf a :=
    ωSup_le _ _ <| by
      rintro i
      

Proof state:
α : Type u_1
β : α → Type u_2
γ : Type u_3
inst✝ : (a : α) → OmegaCompletePartialOrder (β a)
c : Chain ((a : α) → β a)
f : (a : α) → β a
hf : ∀ (i : ℕ), c i ≤ f
a : α
i : ℕ
⊢ (map c (evalOrderHom a)) i ≤ f a

Next tactic:
apply hf
theorem flip₂_continuous' (f : γ → ∀ x, β x) (hf : ∀ x, Continuous' fun g => f g x) :
    Continuous' f :=
  Continuous.of_bundled _ (fun x y h a => (hf a).to_monotone h)
    (by 

Proof state:
α : Type u_1
β : α → Type u_2
γ : Type u_3
inst✝¹ : (x : α) → OmegaCompletePartialOrder (β x)
inst✝ : OmegaCompletePartialOrder γ
f : γ → (x : α) → β x
hf : ∀ (x : α), Continuous' fun g => f g x
⊢ Continuous { toFun := f, monotone' := (_ : ∀ (x y : γ), x ≤ y → ∀ (a : α), (fun g => f g a) x ≤ (fun g => f g a) y) }

Next tactic:
intro c
theorem flip₂_continuous' (f : γ → ∀ x, β x) (hf : ∀ x, Continuous' fun g => f g x) :
    Continuous' f :=
  Continuous.of_bundled _ (fun x y h a => (hf a).to_monotone h)
    (by intro c; 

Proof state:
α : Type u_1
β : α → Type u_2
γ : Type u_3
inst✝¹ : (x : α) → OmegaCompletePartialOrder (β x)
inst✝ : OmegaCompletePartialOrder γ
f : γ → (x : α) → β x
hf : ∀ (x : α), Continuous' fun g => f g x
c : Chain γ
⊢ { toFun := f, monotone' := (_ : ∀ (x y : γ), x ≤ y → ∀ (a : α), (fun g => f g a) x ≤ (fun g => f g a) y) } (ωSup c) =
    ωSup
      (map c { toFun := f, monotone' := (_ : ∀ (x y : γ), x ≤ y → ∀ (a : α), (fun g => f g a) x ≤ (fun g => f g a) y) })

Next tactic:
ext a
theorem flip₂_continuous' (f : γ → ∀ x, β x) (hf : ∀ x, Continuous' fun g => f g x) :
    Continuous' f :=
  Continuous.of_bundled _ (fun x y h a => (hf a).to_monotone h)
    (by intro c; ext a; 

Proof state:
case h
α : Type u_1
β : α → Type u_2
γ : Type u_3
inst✝¹ : (x : α) → OmegaCompletePartialOrder (β x)
inst✝ : OmegaCompletePartialOrder γ
f : γ → (x : α) → β x
hf : ∀ (x : α), Continuous' fun g => f g x
c : Chain γ
a : α
⊢ { toFun := f, monotone' := (_ : ∀ (x y : γ), x ≤ y → ∀ (a : α), (fun g => f g a) x ≤ (fun g => f g a) y) } (ωSup c)
      a =
    ωSup
      (map c { toFun := f, monotone' := (_ : ∀ (x y : γ), x ≤ y → ∀ (a : α), (fun g => f g a) x ≤ (fun g => f g a) y) })
      a

Next tactic:
apply (hf a).to_bundled _ c
theorem ωSup_zip (c₀ : Chain α) (c₁ : Chain β) : ωSup (c₀.zip c₁) = (ωSup c₀, ωSup c₁) := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
c₀ : Chain α
c₁ : Chain β
⊢ ωSup (Chain.zip c₀ c₁) = (ωSup c₀, ωSup c₁)

Next tactic:
apply eq_of_forall_ge_iff
theorem ωSup_zip (c₀ : Chain α) (c₁ : Chain β) : ωSup (c₀.zip c₁) = (ωSup c₀, ωSup c₁) := by
  apply eq_of_forall_ge_iff; 

Proof state:
case H
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
c₀ : Chain α
c₁ : Chain β
⊢ ∀ (c : α × β), ωSup (Chain.zip c₀ c₁) ≤ c ↔ (ωSup c₀, ωSup c₁) ≤ c

Next tactic:
rintro ⟨z₁, z₂⟩
theorem ωSup_zip (c₀ : Chain α) (c₁ : Chain β) : ωSup (c₀.zip c₁) = (ωSup c₀, ωSup c₁) := by
  apply eq_of_forall_ge_iff; rintro ⟨z₁, z₂⟩
  

Proof state:
case H.mk
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
c₀ : Chain α
c₁ : Chain β
z₁ : α
z₂ : β
⊢ ωSup (Chain.zip c₀ c₁) ≤ (z₁, z₂) ↔ (ωSup c₀, ωSup c₁) ≤ (z₁, z₂)

Next tactic:
simp [ωSup_le_iff, forall_and]
/-- 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; apply hs i
  le_ωSup := fun ⟨c, _⟩ i => by 

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

Next tactic:
simp only [OrderHom.coe_mk]
/-- 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; apply hs i
  le_ωSup := fun ⟨c, _⟩ i => by simp only [OrderHom.coe_mk]; 

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

Next tactic:
apply le_iSup_of_le i
/-- 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; apply hs i
  le_ωSup := fun ⟨c, _⟩ i => by simp only [OrderHom.coe_mk]; apply le_iSup_of_le i; 

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

Next tactic:
rfl
/-- 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
    

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

Next tactic:
simp only [iSup_le_iff, OrderHom.coe_mk] at hs ⊢
/-- 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 ⊢; 

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:
intro i