Theorem: Ordinal.enumOrd_isNormal_iff_isClosed
File: Mathlib/SetTheory/Ordinal/Topology.lean

tactic: have Hs := enumOrd_strictMono hs
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
⊢ IsNormal (enumOrd s) ↔ IsClosed s
state_after: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
⊢ IsNormal (enumOrd s) ↔ IsClosed s

tactic: refine
  ⟨fun h => isClosed_iff_sup.2 fun {ι} hι f hf => ?_, fun h =>
    (isNormal_iff_strictMono_limit _).2 ⟨Hs, fun a ha o H => ?_⟩⟩
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
⊢ IsNormal (enumOrd s) ↔ IsClosed s
state_after: case refine_1
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
⊢ sup f ∈ s

case refine_2
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsClosed s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
⊢ enumOrd s a ≤ o

tactic: let g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨_, hf i⟩
state_before: case refine_1
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
⊢ sup f ∈ s
state_after: case refine_1
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
⊢ sup f ∈ s

tactic: suffices enumOrd s (sup.{u, u} g) = sup.{u, u} f by
  rw [← this]
  exact enumOrd_mem hs _
state_before: case refine_1
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
⊢ sup f ∈ s
state_after: case refine_1
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
⊢ enumOrd s (sup g) = sup f

tactic: rw [@IsNormal.sup.{u, u, u} _ h ι g hι]
state_before: case refine_1
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
⊢ enumOrd s (sup g) = sup f
state_after: case refine_1
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
⊢ sup (enumOrd s ∘ g) = sup f

tactic: congr
state_before: case refine_1
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
⊢ sup (enumOrd s ∘ g) = sup f
state_after: case refine_1.e_f
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
⊢ enumOrd s ∘ g = f

tactic: ext x
state_before: case refine_1.e_f
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
⊢ enumOrd s ∘ g = f
state_after: case refine_1.e_f.h
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
x : ι
⊢ (enumOrd s ∘ g) x = f x

tactic: change ((enumOrdOrderIso hs) _).val = f x
state_before: case refine_1.e_f.h
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
x : ι
⊢ (enumOrd s ∘ g) x = f x
state_after: case refine_1.e_f.h
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
x : ι
⊢ ↑((enumOrdOrderIso hs) (g x)) = f x

tactic: rw [OrderIso.apply_symm_apply]
state_before: case refine_1.e_f.h
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
x : ι
⊢ ↑((enumOrdOrderIso hs) (g x)) = f x
state_after: no goals

tactic: rw [← this]
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
this : enumOrd s (sup g) = sup f
⊢ sup f ∈ s
state_after: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
this : enumOrd s (sup g) = sup f
⊢ enumOrd s (sup g) ∈ s

tactic: exact enumOrd_mem hs _
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨f i, ⋯⟩
this : enumOrd s (sup g) = sup f
⊢ enumOrd s (sup g) ∈ s
state_after: no goals

tactic: rw [isClosed_iff_bsup] at h
state_before: case refine_2
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsClosed s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
⊢ enumOrd s a ≤ o
state_after: case refine_2
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
⊢ enumOrd s a ≤ o

tactic: suffices enumOrd s a ≤ bsup.{u, u} a fun b (_ : b < a) => enumOrd s b from
  this.trans (bsup_le H)
state_before: case refine_2
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
⊢ enumOrd s a ≤ o
state_after: case refine_2
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
⊢ enumOrd s a ≤ a.bsup fun b x => enumOrd s b

tactic: cases' enumOrd_surjective hs _
    (h ha.1 (fun b _ => enumOrd s b) fun b _ => enumOrd_mem hs b) with
  b hb
state_before: case refine_2
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
⊢ enumOrd s a ≤ a.bsup fun b x => enumOrd s b
state_after: case refine_2.intro
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
⊢ enumOrd s a ≤ a.bsup fun b x => enumOrd s b

tactic: rw [← hb]
state_before: case refine_2.intro
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
⊢ enumOrd s a ≤ a.bsup fun b x => enumOrd s b
state_after: case refine_2.intro
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
⊢ enumOrd s a ≤ enumOrd s b

tactic: apply Hs.monotone
state_before: case refine_2.intro
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
⊢ enumOrd s a ≤ enumOrd s b
state_after: case refine_2.intro.a
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
⊢ a ≤ b

tactic: by_contra! hba
state_before: case refine_2.intro.a
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
⊢ a ≤ b
state_after: case refine_2.intro.a
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
hba : b < a
⊢ False

tactic: apply (Hs (lt_succ b)).not_le
state_before: case refine_2.intro.a
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
hba : b < a
⊢ False
state_after: case refine_2.intro.a
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
hba : b < a
⊢ enumOrd s (succ b) ≤ enumOrd s b

tactic: rw [hb]
state_before: case refine_2.intro.a
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
hba : b < a
⊢ enumOrd s (succ b) ≤ enumOrd s b
state_after: case refine_2.intro.a
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
hba : b < a
⊢ enumOrd s (succ b) ≤ a.bsup fun b x => enumOrd s b

tactic: exact le_bsup.{u, u} _ _ (ha.2 _ hba)
state_before: case refine_2.intro.a
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal.{u}},
    o ≠ 0 →
      ∀ (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), (∀ (i : Ordinal.{u}) (hi : i < o), f i hi ∈ s) → o.bsup f ∈ s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
b : Ordinal.{u}
hb : enumOrd s b = a.bsup fun b x => enumOrd s b
hba : b < a
⊢ enumOrd s (succ b) ≤ a.bsup fun b x => enumOrd s b
state_after: no goals