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

tactic: have Hs := enumOrd_strictMono hs
state_before: s : Set Ordinal
a : Ordinal
hs : Set.Unbounded (fun x x_1 => x < x_1) 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
a : Ordinal
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
⊢ IsNormal (enumOrd s) ↔ IsClosed s

tactic: let g : ι → Ordinal.{u} := fun i => (enumOrdOrderIso hs).symm ⟨_, hf i⟩
state_before: case refine'_1
s : Set Ordinal
a : Ordinal
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
hf : ∀ (i : ι), f i ∈ s
⊢ 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
a : Ordinal
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
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal := fun i => ↑(OrderIso.symm (enumOrdOrderIso hs)) { val := f i, property := (_ : f i ∈ s) }
⊢ sup f ∈ s

tactic: rw [@IsNormal.sup.{u, u, u} _ h ι g hι]
state_before: case refine'_1
s : Set Ordinal
a : Ordinal
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
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal := fun i => ↑(OrderIso.symm (enumOrdOrderIso hs)) { val := f i, property := (_ : f i ∈ s) }
⊢ enumOrd s (sup g) = sup f

tactic: congr
state_before: case refine'_1
s : Set Ordinal
a : Ordinal
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
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal := fun i => ↑(OrderIso.symm (enumOrdOrderIso hs)) { val := f i, property := (_ : f i ∈ s) }
⊢ sup (enumOrd s ∘ g) = sup f

tactic: ext x
state_before: case refine'_1.e_f
s : Set Ordinal
a : Ordinal
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
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal := fun i => ↑(OrderIso.symm (enumOrdOrderIso hs)) { val := f i, property := (_ : f i ∈ s) }
⊢ enumOrd s ∘ g = f

tactic: change ((enumOrdOrderIso hs) _).val = f x
state_before: case refine'_1.e_f.h
s : Set Ordinal
a : Ordinal
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
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal := fun i => ↑(OrderIso.symm (enumOrdOrderIso hs)) { val := f i, property := (_ : f i ∈ s) }
x : ι
⊢ (enumOrd s ∘ g) x = f x

tactic: rw [OrderIso.apply_symm_apply]
state_before: case refine'_1.e_f.h
s : Set Ordinal
a : Ordinal
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
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal := fun i => ↑(OrderIso.symm (enumOrdOrderIso hs)) { val := f i, property := (_ : f i ∈ s) }
x : ι
⊢ ↑(↑(enumOrdOrderIso hs) (g x)) = f x

tactic: rw [← this]
state_before: s : Set Ordinal
a : Ordinal
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
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal := fun i => ↑(OrderIso.symm (enumOrdOrderIso hs)) { val := f i, property := (_ : f i ∈ s) }
this : enumOrd s (sup g) = sup f
⊢ sup f ∈ s

tactic: exact enumOrd_mem hs _
state_before: s : Set Ordinal
a : Ordinal
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
hf : ∀ (i : ι), f i ∈ s
g : ι → Ordinal := fun i => ↑(OrderIso.symm (enumOrdOrderIso hs)) { val := f i, property := (_ : f i ∈ s) }
this : enumOrd s (sup g) = sup f
⊢ enumOrd s (sup g) ∈ s

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

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

case this
s : Set Ordinal
a✝ : Ordinal
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal},
    o ≠ 0 → ∀ (f : (a : Ordinal) → a < o → Ordinal), (∀ (i : Ordinal) (hi : i < o), f i hi ∈ s) → bsup o f ∈ s
a : Ordinal
ha : IsLimit a
o : Ordinal
H : ∀ (b : Ordinal), b < a → enumOrd s b ≤ o
⊢ enumOrd s a ≤ bsup a 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 this
s : Set Ordinal
a✝ : Ordinal
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h :
  ∀ {o : Ordinal},
    o ≠ 0 → ∀ (f : (a : Ordinal) → a < o → Ordinal), (∀ (i : Ordinal) (hi : i < o), f i hi ∈ s) → bsup o f ∈ s
a : Ordinal
ha : IsLimit a
o : Ordinal
H : ∀ (b : Ordinal), b < a → enumOrd s b ≤ o
⊢ enumOrd s a ≤ bsup a fun b x => enumOrd s b

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

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

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

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

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

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